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/api/graphql/models"
19 "github.com/MichaelMure/git-bug/bug"
20 "github.com/MichaelMure/git-bug/repository"
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 AddCommentAndCloseBugPayload struct {
71 Bug func(childComplexity int) int
72 ClientMutationID func(childComplexity int) int
73 CommentOperation func(childComplexity int) int
74 StatusOperation func(childComplexity int) int
75 }
76
77 AddCommentOperation struct {
78 Author func(childComplexity int) int
79 Date func(childComplexity int) int
80 Files func(childComplexity int) int
81 ID func(childComplexity int) int
82 Message func(childComplexity int) int
83 }
84
85 AddCommentPayload struct {
86 Bug func(childComplexity int) int
87 ClientMutationID func(childComplexity int) int
88 Operation func(childComplexity int) int
89 }
90
91 AddCommentTimelineItem struct {
92 Author func(childComplexity int) int
93 CreatedAt func(childComplexity int) int
94 Edited func(childComplexity int) int
95 Files func(childComplexity int) int
96 History func(childComplexity int) int
97 ID func(childComplexity int) int
98 LastEdit func(childComplexity int) int
99 Message func(childComplexity int) int
100 MessageIsEmpty func(childComplexity int) int
101 }
102
103 Bug struct {
104 Actors func(childComplexity int, after *string, before *string, first *int, last *int) int
105 Author func(childComplexity int) int
106 Comments func(childComplexity int, after *string, before *string, first *int, last *int) int
107 CreatedAt func(childComplexity int) int
108 HumanID func(childComplexity int) int
109 ID func(childComplexity int) int
110 Labels func(childComplexity int) int
111 LastEdit func(childComplexity int) int
112 Operations func(childComplexity int, after *string, before *string, first *int, last *int) int
113 Participants func(childComplexity int, after *string, before *string, first *int, last *int) int
114 Status func(childComplexity int) int
115 Timeline func(childComplexity int, after *string, before *string, first *int, last *int) int
116 Title func(childComplexity int) int
117 }
118
119 BugConnection struct {
120 Edges func(childComplexity int) int
121 Nodes func(childComplexity int) int
122 PageInfo func(childComplexity int) int
123 TotalCount func(childComplexity int) int
124 }
125
126 BugEdge struct {
127 Cursor func(childComplexity int) int
128 Node func(childComplexity int) int
129 }
130
131 ChangeLabelPayload struct {
132 Bug func(childComplexity int) int
133 ClientMutationID func(childComplexity int) int
134 Operation func(childComplexity int) int
135 Results func(childComplexity int) int
136 }
137
138 CloseBugPayload struct {
139 Bug func(childComplexity int) int
140 ClientMutationID func(childComplexity int) int
141 Operation func(childComplexity int) int
142 }
143
144 Color struct {
145 B func(childComplexity int) int
146 G func(childComplexity int) int
147 R func(childComplexity int) int
148 }
149
150 Comment struct {
151 Author func(childComplexity int) int
152 Files func(childComplexity int) int
153 Message func(childComplexity int) int
154 }
155
156 CommentConnection struct {
157 Edges func(childComplexity int) int
158 Nodes func(childComplexity int) int
159 PageInfo func(childComplexity int) int
160 TotalCount func(childComplexity int) int
161 }
162
163 CommentEdge struct {
164 Cursor func(childComplexity int) int
165 Node func(childComplexity int) int
166 }
167
168 CommentHistoryStep struct {
169 Date func(childComplexity int) int
170 Message func(childComplexity int) int
171 }
172
173 CreateOperation struct {
174 Author func(childComplexity int) int
175 Date func(childComplexity int) int
176 Files func(childComplexity int) int
177 ID func(childComplexity int) int
178 Message func(childComplexity int) int
179 Title func(childComplexity int) int
180 }
181
182 CreateTimelineItem struct {
183 Author func(childComplexity int) int
184 CreatedAt func(childComplexity int) int
185 Edited func(childComplexity int) int
186 Files func(childComplexity int) int
187 History func(childComplexity int) int
188 ID func(childComplexity int) int
189 LastEdit func(childComplexity int) int
190 Message func(childComplexity int) int
191 MessageIsEmpty func(childComplexity int) int
192 }
193
194 EditCommentOperation struct {
195 Author func(childComplexity int) int
196 Date func(childComplexity int) int
197 Files func(childComplexity int) int
198 ID func(childComplexity int) int
199 Message func(childComplexity int) int
200 Target func(childComplexity int) int
201 }
202
203 EditCommentPayload struct {
204 Bug func(childComplexity int) int
205 ClientMutationID func(childComplexity int) int
206 Operation func(childComplexity int) int
207 }
208
209 Identity struct {
210 AvatarUrl func(childComplexity int) int
211 DisplayName func(childComplexity int) int
212 Email func(childComplexity int) int
213 HumanID func(childComplexity int) int
214 ID func(childComplexity int) int
215 IsProtected func(childComplexity int) int
216 Login func(childComplexity int) int
217 Name func(childComplexity int) int
218 }
219
220 IdentityConnection struct {
221 Edges func(childComplexity int) int
222 Nodes func(childComplexity int) int
223 PageInfo func(childComplexity int) int
224 TotalCount func(childComplexity int) int
225 }
226
227 IdentityEdge struct {
228 Cursor func(childComplexity int) int
229 Node func(childComplexity int) int
230 }
231
232 Label struct {
233 Color func(childComplexity int) int
234 Name func(childComplexity int) int
235 }
236
237 LabelChangeOperation struct {
238 Added func(childComplexity int) int
239 Author func(childComplexity int) int
240 Date func(childComplexity int) int
241 ID func(childComplexity int) int
242 Removed func(childComplexity int) int
243 }
244
245 LabelChangeResult struct {
246 Label func(childComplexity int) int
247 Status func(childComplexity int) int
248 }
249
250 LabelChangeTimelineItem struct {
251 Added func(childComplexity int) int
252 Author func(childComplexity int) int
253 Date func(childComplexity int) int
254 ID func(childComplexity int) int
255 Removed func(childComplexity int) int
256 }
257
258 LabelConnection struct {
259 Edges func(childComplexity int) int
260 Nodes func(childComplexity int) int
261 PageInfo func(childComplexity int) int
262 TotalCount func(childComplexity int) int
263 }
264
265 LabelEdge struct {
266 Cursor func(childComplexity int) int
267 Node func(childComplexity int) int
268 }
269
270 Mutation struct {
271 AddComment func(childComplexity int, input models.AddCommentInput) int
272 AddCommentAndClose func(childComplexity int, input models.AddCommentAndCloseBugInput) int
273 ChangeLabels func(childComplexity int, input *models.ChangeLabelInput) int
274 CloseBug func(childComplexity int, input models.CloseBugInput) int
275 EditComment func(childComplexity int, input models.EditCommentInput) int
276 NewBug func(childComplexity int, input models.NewBugInput) int
277 OpenBug func(childComplexity int, input models.OpenBugInput) int
278 SetTitle func(childComplexity int, input models.SetTitleInput) int
279 }
280
281 NewBugPayload struct {
282 Bug func(childComplexity int) int
283 ClientMutationID func(childComplexity int) int
284 Operation func(childComplexity int) int
285 }
286
287 OpenBugPayload struct {
288 Bug func(childComplexity int) int
289 ClientMutationID func(childComplexity int) int
290 Operation func(childComplexity int) int
291 }
292
293 OperationConnection struct {
294 Edges func(childComplexity int) int
295 Nodes func(childComplexity int) int
296 PageInfo func(childComplexity int) int
297 TotalCount func(childComplexity int) int
298 }
299
300 OperationEdge struct {
301 Cursor func(childComplexity int) int
302 Node func(childComplexity int) int
303 }
304
305 PageInfo struct {
306 EndCursor func(childComplexity int) int
307 HasNextPage func(childComplexity int) int
308 HasPreviousPage func(childComplexity int) int
309 StartCursor func(childComplexity int) int
310 }
311
312 Query struct {
313 Repository func(childComplexity int, ref *string) int
314 }
315
316 Repository struct {
317 AllBugs func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
318 AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
319 Bug func(childComplexity int, prefix string) int
320 Identity func(childComplexity int, prefix string) int
321 Name func(childComplexity int) int
322 UserIdentity func(childComplexity int) int
323 ValidLabels func(childComplexity int, after *string, before *string, first *int, last *int) int
324 }
325
326 SetStatusOperation struct {
327 Author func(childComplexity int) int
328 Date func(childComplexity int) int
329 ID func(childComplexity int) int
330 Status func(childComplexity int) int
331 }
332
333 SetStatusTimelineItem struct {
334 Author func(childComplexity int) int
335 Date func(childComplexity int) int
336 ID func(childComplexity int) int
337 Status func(childComplexity int) int
338 }
339
340 SetTitleOperation struct {
341 Author func(childComplexity int) int
342 Date func(childComplexity int) int
343 ID func(childComplexity int) int
344 Title func(childComplexity int) int
345 Was func(childComplexity int) int
346 }
347
348 SetTitlePayload struct {
349 Bug func(childComplexity int) int
350 ClientMutationID func(childComplexity int) int
351 Operation func(childComplexity int) int
352 }
353
354 SetTitleTimelineItem struct {
355 Author func(childComplexity int) int
356 Date func(childComplexity int) int
357 ID func(childComplexity int) int
358 Title func(childComplexity int) int
359 Was func(childComplexity int) int
360 }
361
362 TimelineItemConnection struct {
363 Edges func(childComplexity int) int
364 Nodes func(childComplexity int) int
365 PageInfo func(childComplexity int) int
366 TotalCount func(childComplexity int) int
367 }
368
369 TimelineItemEdge struct {
370 Cursor func(childComplexity int) int
371 Node func(childComplexity int) int
372 }
373}
374
375type AddCommentOperationResolver interface {
376 ID(ctx context.Context, obj *bug.AddCommentOperation) (string, error)
377 Author(ctx context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error)
378 Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
379}
380type AddCommentTimelineItemResolver interface {
381 ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (string, error)
382 Author(ctx context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, error)
383
384 CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
385 LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
386}
387type BugResolver interface {
388 ID(ctx context.Context, obj models.BugWrapper) (string, error)
389 HumanID(ctx context.Context, obj models.BugWrapper) (string, error)
390 Status(ctx context.Context, obj models.BugWrapper) (models.Status, error)
391
392 Actors(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
393 Participants(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
394 Comments(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
395 Timeline(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
396 Operations(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
397}
398type ColorResolver interface {
399 R(ctx context.Context, obj *color.RGBA) (int, error)
400 G(ctx context.Context, obj *color.RGBA) (int, error)
401 B(ctx context.Context, obj *color.RGBA) (int, error)
402}
403type CommentResolver interface {
404 Author(ctx context.Context, obj *bug.Comment) (models.IdentityWrapper, error)
405}
406type CommentHistoryStepResolver interface {
407 Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
408}
409type CreateOperationResolver interface {
410 ID(ctx context.Context, obj *bug.CreateOperation) (string, error)
411 Author(ctx context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error)
412 Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
413}
414type CreateTimelineItemResolver interface {
415 ID(ctx context.Context, obj *bug.CreateTimelineItem) (string, error)
416 Author(ctx context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error)
417
418 CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
419 LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
420}
421type EditCommentOperationResolver interface {
422 ID(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
423 Author(ctx context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error)
424 Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
425 Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
426}
427type IdentityResolver interface {
428 ID(ctx context.Context, obj models.IdentityWrapper) (string, error)
429 HumanID(ctx context.Context, obj models.IdentityWrapper) (string, error)
430}
431type LabelResolver interface {
432 Name(ctx context.Context, obj *bug.Label) (string, error)
433 Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
434}
435type LabelChangeOperationResolver interface {
436 ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
437 Author(ctx context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error)
438 Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
439}
440type LabelChangeResultResolver interface {
441 Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
442}
443type LabelChangeTimelineItemResolver interface {
444 ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
445 Author(ctx context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error)
446 Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
447}
448type MutationResolver interface {
449 NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
450 AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
451 AddCommentAndClose(ctx context.Context, input models.AddCommentAndCloseBugInput) (*models.AddCommentAndCloseBugPayload, error)
452 EditComment(ctx context.Context, input models.EditCommentInput) (*models.EditCommentPayload, error)
453 ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
454 OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
455 CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
456 SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
457}
458type QueryResolver interface {
459 Repository(ctx context.Context, ref *string) (*models.Repository, error)
460}
461type RepositoryResolver interface {
462 Name(ctx context.Context, obj *models.Repository) (*string, error)
463 AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
464 Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
465 AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
466 Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
467 UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
468 ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
469}
470type SetStatusOperationResolver interface {
471 ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
472 Author(ctx context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error)
473 Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
474 Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
475}
476type SetStatusTimelineItemResolver interface {
477 ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
478 Author(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error)
479 Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
480 Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
481}
482type SetTitleOperationResolver interface {
483 ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
484 Author(ctx context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error)
485 Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
486}
487type SetTitleTimelineItemResolver interface {
488 ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
489 Author(ctx context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error)
490 Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
491}
492
493type executableSchema struct {
494 resolvers ResolverRoot
495 directives DirectiveRoot
496 complexity ComplexityRoot
497}
498
499func (e *executableSchema) Schema() *ast.Schema {
500 return parsedSchema
501}
502
503func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
504 ec := executionContext{nil, e}
505 _ = ec
506 switch typeName + "." + field {
507
508 case "AddCommentAndCloseBugPayload.bug":
509 if e.complexity.AddCommentAndCloseBugPayload.Bug == nil {
510 break
511 }
512
513 return e.complexity.AddCommentAndCloseBugPayload.Bug(childComplexity), true
514
515 case "AddCommentAndCloseBugPayload.clientMutationId":
516 if e.complexity.AddCommentAndCloseBugPayload.ClientMutationID == nil {
517 break
518 }
519
520 return e.complexity.AddCommentAndCloseBugPayload.ClientMutationID(childComplexity), true
521
522 case "AddCommentAndCloseBugPayload.commentOperation":
523 if e.complexity.AddCommentAndCloseBugPayload.CommentOperation == nil {
524 break
525 }
526
527 return e.complexity.AddCommentAndCloseBugPayload.CommentOperation(childComplexity), true
528
529 case "AddCommentAndCloseBugPayload.statusOperation":
530 if e.complexity.AddCommentAndCloseBugPayload.StatusOperation == nil {
531 break
532 }
533
534 return e.complexity.AddCommentAndCloseBugPayload.StatusOperation(childComplexity), true
535
536 case "AddCommentOperation.author":
537 if e.complexity.AddCommentOperation.Author == nil {
538 break
539 }
540
541 return e.complexity.AddCommentOperation.Author(childComplexity), true
542
543 case "AddCommentOperation.date":
544 if e.complexity.AddCommentOperation.Date == nil {
545 break
546 }
547
548 return e.complexity.AddCommentOperation.Date(childComplexity), true
549
550 case "AddCommentOperation.files":
551 if e.complexity.AddCommentOperation.Files == nil {
552 break
553 }
554
555 return e.complexity.AddCommentOperation.Files(childComplexity), true
556
557 case "AddCommentOperation.id":
558 if e.complexity.AddCommentOperation.ID == nil {
559 break
560 }
561
562 return e.complexity.AddCommentOperation.ID(childComplexity), true
563
564 case "AddCommentOperation.message":
565 if e.complexity.AddCommentOperation.Message == nil {
566 break
567 }
568
569 return e.complexity.AddCommentOperation.Message(childComplexity), true
570
571 case "AddCommentPayload.bug":
572 if e.complexity.AddCommentPayload.Bug == nil {
573 break
574 }
575
576 return e.complexity.AddCommentPayload.Bug(childComplexity), true
577
578 case "AddCommentPayload.clientMutationId":
579 if e.complexity.AddCommentPayload.ClientMutationID == nil {
580 break
581 }
582
583 return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
584
585 case "AddCommentPayload.operation":
586 if e.complexity.AddCommentPayload.Operation == nil {
587 break
588 }
589
590 return e.complexity.AddCommentPayload.Operation(childComplexity), true
591
592 case "AddCommentTimelineItem.author":
593 if e.complexity.AddCommentTimelineItem.Author == nil {
594 break
595 }
596
597 return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
598
599 case "AddCommentTimelineItem.createdAt":
600 if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
601 break
602 }
603
604 return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
605
606 case "AddCommentTimelineItem.edited":
607 if e.complexity.AddCommentTimelineItem.Edited == nil {
608 break
609 }
610
611 return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
612
613 case "AddCommentTimelineItem.files":
614 if e.complexity.AddCommentTimelineItem.Files == nil {
615 break
616 }
617
618 return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
619
620 case "AddCommentTimelineItem.history":
621 if e.complexity.AddCommentTimelineItem.History == nil {
622 break
623 }
624
625 return e.complexity.AddCommentTimelineItem.History(childComplexity), true
626
627 case "AddCommentTimelineItem.id":
628 if e.complexity.AddCommentTimelineItem.ID == nil {
629 break
630 }
631
632 return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
633
634 case "AddCommentTimelineItem.lastEdit":
635 if e.complexity.AddCommentTimelineItem.LastEdit == nil {
636 break
637 }
638
639 return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
640
641 case "AddCommentTimelineItem.message":
642 if e.complexity.AddCommentTimelineItem.Message == nil {
643 break
644 }
645
646 return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
647
648 case "AddCommentTimelineItem.messageIsEmpty":
649 if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
650 break
651 }
652
653 return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
654
655 case "Bug.actors":
656 if e.complexity.Bug.Actors == nil {
657 break
658 }
659
660 args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
661 if err != nil {
662 return 0, false
663 }
664
665 return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
666
667 case "Bug.author":
668 if e.complexity.Bug.Author == nil {
669 break
670 }
671
672 return e.complexity.Bug.Author(childComplexity), true
673
674 case "Bug.comments":
675 if e.complexity.Bug.Comments == nil {
676 break
677 }
678
679 args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
680 if err != nil {
681 return 0, false
682 }
683
684 return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
685
686 case "Bug.createdAt":
687 if e.complexity.Bug.CreatedAt == nil {
688 break
689 }
690
691 return e.complexity.Bug.CreatedAt(childComplexity), true
692
693 case "Bug.humanId":
694 if e.complexity.Bug.HumanID == nil {
695 break
696 }
697
698 return e.complexity.Bug.HumanID(childComplexity), true
699
700 case "Bug.id":
701 if e.complexity.Bug.ID == nil {
702 break
703 }
704
705 return e.complexity.Bug.ID(childComplexity), true
706
707 case "Bug.labels":
708 if e.complexity.Bug.Labels == nil {
709 break
710 }
711
712 return e.complexity.Bug.Labels(childComplexity), true
713
714 case "Bug.lastEdit":
715 if e.complexity.Bug.LastEdit == nil {
716 break
717 }
718
719 return e.complexity.Bug.LastEdit(childComplexity), true
720
721 case "Bug.operations":
722 if e.complexity.Bug.Operations == nil {
723 break
724 }
725
726 args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
727 if err != nil {
728 return 0, false
729 }
730
731 return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
732
733 case "Bug.participants":
734 if e.complexity.Bug.Participants == nil {
735 break
736 }
737
738 args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
739 if err != nil {
740 return 0, false
741 }
742
743 return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
744
745 case "Bug.status":
746 if e.complexity.Bug.Status == nil {
747 break
748 }
749
750 return e.complexity.Bug.Status(childComplexity), true
751
752 case "Bug.timeline":
753 if e.complexity.Bug.Timeline == nil {
754 break
755 }
756
757 args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
758 if err != nil {
759 return 0, false
760 }
761
762 return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
763
764 case "Bug.title":
765 if e.complexity.Bug.Title == nil {
766 break
767 }
768
769 return e.complexity.Bug.Title(childComplexity), true
770
771 case "BugConnection.edges":
772 if e.complexity.BugConnection.Edges == nil {
773 break
774 }
775
776 return e.complexity.BugConnection.Edges(childComplexity), true
777
778 case "BugConnection.nodes":
779 if e.complexity.BugConnection.Nodes == nil {
780 break
781 }
782
783 return e.complexity.BugConnection.Nodes(childComplexity), true
784
785 case "BugConnection.pageInfo":
786 if e.complexity.BugConnection.PageInfo == nil {
787 break
788 }
789
790 return e.complexity.BugConnection.PageInfo(childComplexity), true
791
792 case "BugConnection.totalCount":
793 if e.complexity.BugConnection.TotalCount == nil {
794 break
795 }
796
797 return e.complexity.BugConnection.TotalCount(childComplexity), true
798
799 case "BugEdge.cursor":
800 if e.complexity.BugEdge.Cursor == nil {
801 break
802 }
803
804 return e.complexity.BugEdge.Cursor(childComplexity), true
805
806 case "BugEdge.node":
807 if e.complexity.BugEdge.Node == nil {
808 break
809 }
810
811 return e.complexity.BugEdge.Node(childComplexity), true
812
813 case "ChangeLabelPayload.bug":
814 if e.complexity.ChangeLabelPayload.Bug == nil {
815 break
816 }
817
818 return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
819
820 case "ChangeLabelPayload.clientMutationId":
821 if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
822 break
823 }
824
825 return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
826
827 case "ChangeLabelPayload.operation":
828 if e.complexity.ChangeLabelPayload.Operation == nil {
829 break
830 }
831
832 return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
833
834 case "ChangeLabelPayload.results":
835 if e.complexity.ChangeLabelPayload.Results == nil {
836 break
837 }
838
839 return e.complexity.ChangeLabelPayload.Results(childComplexity), true
840
841 case "CloseBugPayload.bug":
842 if e.complexity.CloseBugPayload.Bug == nil {
843 break
844 }
845
846 return e.complexity.CloseBugPayload.Bug(childComplexity), true
847
848 case "CloseBugPayload.clientMutationId":
849 if e.complexity.CloseBugPayload.ClientMutationID == nil {
850 break
851 }
852
853 return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
854
855 case "CloseBugPayload.operation":
856 if e.complexity.CloseBugPayload.Operation == nil {
857 break
858 }
859
860 return e.complexity.CloseBugPayload.Operation(childComplexity), true
861
862 case "Color.B":
863 if e.complexity.Color.B == nil {
864 break
865 }
866
867 return e.complexity.Color.B(childComplexity), true
868
869 case "Color.G":
870 if e.complexity.Color.G == nil {
871 break
872 }
873
874 return e.complexity.Color.G(childComplexity), true
875
876 case "Color.R":
877 if e.complexity.Color.R == nil {
878 break
879 }
880
881 return e.complexity.Color.R(childComplexity), true
882
883 case "Comment.author":
884 if e.complexity.Comment.Author == nil {
885 break
886 }
887
888 return e.complexity.Comment.Author(childComplexity), true
889
890 case "Comment.files":
891 if e.complexity.Comment.Files == nil {
892 break
893 }
894
895 return e.complexity.Comment.Files(childComplexity), true
896
897 case "Comment.message":
898 if e.complexity.Comment.Message == nil {
899 break
900 }
901
902 return e.complexity.Comment.Message(childComplexity), true
903
904 case "CommentConnection.edges":
905 if e.complexity.CommentConnection.Edges == nil {
906 break
907 }
908
909 return e.complexity.CommentConnection.Edges(childComplexity), true
910
911 case "CommentConnection.nodes":
912 if e.complexity.CommentConnection.Nodes == nil {
913 break
914 }
915
916 return e.complexity.CommentConnection.Nodes(childComplexity), true
917
918 case "CommentConnection.pageInfo":
919 if e.complexity.CommentConnection.PageInfo == nil {
920 break
921 }
922
923 return e.complexity.CommentConnection.PageInfo(childComplexity), true
924
925 case "CommentConnection.totalCount":
926 if e.complexity.CommentConnection.TotalCount == nil {
927 break
928 }
929
930 return e.complexity.CommentConnection.TotalCount(childComplexity), true
931
932 case "CommentEdge.cursor":
933 if e.complexity.CommentEdge.Cursor == nil {
934 break
935 }
936
937 return e.complexity.CommentEdge.Cursor(childComplexity), true
938
939 case "CommentEdge.node":
940 if e.complexity.CommentEdge.Node == nil {
941 break
942 }
943
944 return e.complexity.CommentEdge.Node(childComplexity), true
945
946 case "CommentHistoryStep.date":
947 if e.complexity.CommentHistoryStep.Date == nil {
948 break
949 }
950
951 return e.complexity.CommentHistoryStep.Date(childComplexity), true
952
953 case "CommentHistoryStep.message":
954 if e.complexity.CommentHistoryStep.Message == nil {
955 break
956 }
957
958 return e.complexity.CommentHistoryStep.Message(childComplexity), true
959
960 case "CreateOperation.author":
961 if e.complexity.CreateOperation.Author == nil {
962 break
963 }
964
965 return e.complexity.CreateOperation.Author(childComplexity), true
966
967 case "CreateOperation.date":
968 if e.complexity.CreateOperation.Date == nil {
969 break
970 }
971
972 return e.complexity.CreateOperation.Date(childComplexity), true
973
974 case "CreateOperation.files":
975 if e.complexity.CreateOperation.Files == nil {
976 break
977 }
978
979 return e.complexity.CreateOperation.Files(childComplexity), true
980
981 case "CreateOperation.id":
982 if e.complexity.CreateOperation.ID == nil {
983 break
984 }
985
986 return e.complexity.CreateOperation.ID(childComplexity), true
987
988 case "CreateOperation.message":
989 if e.complexity.CreateOperation.Message == nil {
990 break
991 }
992
993 return e.complexity.CreateOperation.Message(childComplexity), true
994
995 case "CreateOperation.title":
996 if e.complexity.CreateOperation.Title == nil {
997 break
998 }
999
1000 return e.complexity.CreateOperation.Title(childComplexity), true
1001
1002 case "CreateTimelineItem.author":
1003 if e.complexity.CreateTimelineItem.Author == nil {
1004 break
1005 }
1006
1007 return e.complexity.CreateTimelineItem.Author(childComplexity), true
1008
1009 case "CreateTimelineItem.createdAt":
1010 if e.complexity.CreateTimelineItem.CreatedAt == nil {
1011 break
1012 }
1013
1014 return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
1015
1016 case "CreateTimelineItem.edited":
1017 if e.complexity.CreateTimelineItem.Edited == nil {
1018 break
1019 }
1020
1021 return e.complexity.CreateTimelineItem.Edited(childComplexity), true
1022
1023 case "CreateTimelineItem.files":
1024 if e.complexity.CreateTimelineItem.Files == nil {
1025 break
1026 }
1027
1028 return e.complexity.CreateTimelineItem.Files(childComplexity), true
1029
1030 case "CreateTimelineItem.history":
1031 if e.complexity.CreateTimelineItem.History == nil {
1032 break
1033 }
1034
1035 return e.complexity.CreateTimelineItem.History(childComplexity), true
1036
1037 case "CreateTimelineItem.id":
1038 if e.complexity.CreateTimelineItem.ID == nil {
1039 break
1040 }
1041
1042 return e.complexity.CreateTimelineItem.ID(childComplexity), true
1043
1044 case "CreateTimelineItem.lastEdit":
1045 if e.complexity.CreateTimelineItem.LastEdit == nil {
1046 break
1047 }
1048
1049 return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
1050
1051 case "CreateTimelineItem.message":
1052 if e.complexity.CreateTimelineItem.Message == nil {
1053 break
1054 }
1055
1056 return e.complexity.CreateTimelineItem.Message(childComplexity), true
1057
1058 case "CreateTimelineItem.messageIsEmpty":
1059 if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
1060 break
1061 }
1062
1063 return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
1064
1065 case "EditCommentOperation.author":
1066 if e.complexity.EditCommentOperation.Author == nil {
1067 break
1068 }
1069
1070 return e.complexity.EditCommentOperation.Author(childComplexity), true
1071
1072 case "EditCommentOperation.date":
1073 if e.complexity.EditCommentOperation.Date == nil {
1074 break
1075 }
1076
1077 return e.complexity.EditCommentOperation.Date(childComplexity), true
1078
1079 case "EditCommentOperation.files":
1080 if e.complexity.EditCommentOperation.Files == nil {
1081 break
1082 }
1083
1084 return e.complexity.EditCommentOperation.Files(childComplexity), true
1085
1086 case "EditCommentOperation.id":
1087 if e.complexity.EditCommentOperation.ID == nil {
1088 break
1089 }
1090
1091 return e.complexity.EditCommentOperation.ID(childComplexity), true
1092
1093 case "EditCommentOperation.message":
1094 if e.complexity.EditCommentOperation.Message == nil {
1095 break
1096 }
1097
1098 return e.complexity.EditCommentOperation.Message(childComplexity), true
1099
1100 case "EditCommentOperation.target":
1101 if e.complexity.EditCommentOperation.Target == nil {
1102 break
1103 }
1104
1105 return e.complexity.EditCommentOperation.Target(childComplexity), true
1106
1107 case "EditCommentPayload.bug":
1108 if e.complexity.EditCommentPayload.Bug == nil {
1109 break
1110 }
1111
1112 return e.complexity.EditCommentPayload.Bug(childComplexity), true
1113
1114 case "EditCommentPayload.clientMutationId":
1115 if e.complexity.EditCommentPayload.ClientMutationID == nil {
1116 break
1117 }
1118
1119 return e.complexity.EditCommentPayload.ClientMutationID(childComplexity), true
1120
1121 case "EditCommentPayload.operation":
1122 if e.complexity.EditCommentPayload.Operation == nil {
1123 break
1124 }
1125
1126 return e.complexity.EditCommentPayload.Operation(childComplexity), true
1127
1128 case "Identity.avatarUrl":
1129 if e.complexity.Identity.AvatarUrl == nil {
1130 break
1131 }
1132
1133 return e.complexity.Identity.AvatarUrl(childComplexity), true
1134
1135 case "Identity.displayName":
1136 if e.complexity.Identity.DisplayName == nil {
1137 break
1138 }
1139
1140 return e.complexity.Identity.DisplayName(childComplexity), true
1141
1142 case "Identity.email":
1143 if e.complexity.Identity.Email == nil {
1144 break
1145 }
1146
1147 return e.complexity.Identity.Email(childComplexity), true
1148
1149 case "Identity.humanId":
1150 if e.complexity.Identity.HumanID == nil {
1151 break
1152 }
1153
1154 return e.complexity.Identity.HumanID(childComplexity), true
1155
1156 case "Identity.id":
1157 if e.complexity.Identity.ID == nil {
1158 break
1159 }
1160
1161 return e.complexity.Identity.ID(childComplexity), true
1162
1163 case "Identity.isProtected":
1164 if e.complexity.Identity.IsProtected == nil {
1165 break
1166 }
1167
1168 return e.complexity.Identity.IsProtected(childComplexity), true
1169
1170 case "Identity.login":
1171 if e.complexity.Identity.Login == nil {
1172 break
1173 }
1174
1175 return e.complexity.Identity.Login(childComplexity), true
1176
1177 case "Identity.name":
1178 if e.complexity.Identity.Name == nil {
1179 break
1180 }
1181
1182 return e.complexity.Identity.Name(childComplexity), true
1183
1184 case "IdentityConnection.edges":
1185 if e.complexity.IdentityConnection.Edges == nil {
1186 break
1187 }
1188
1189 return e.complexity.IdentityConnection.Edges(childComplexity), true
1190
1191 case "IdentityConnection.nodes":
1192 if e.complexity.IdentityConnection.Nodes == nil {
1193 break
1194 }
1195
1196 return e.complexity.IdentityConnection.Nodes(childComplexity), true
1197
1198 case "IdentityConnection.pageInfo":
1199 if e.complexity.IdentityConnection.PageInfo == nil {
1200 break
1201 }
1202
1203 return e.complexity.IdentityConnection.PageInfo(childComplexity), true
1204
1205 case "IdentityConnection.totalCount":
1206 if e.complexity.IdentityConnection.TotalCount == nil {
1207 break
1208 }
1209
1210 return e.complexity.IdentityConnection.TotalCount(childComplexity), true
1211
1212 case "IdentityEdge.cursor":
1213 if e.complexity.IdentityEdge.Cursor == nil {
1214 break
1215 }
1216
1217 return e.complexity.IdentityEdge.Cursor(childComplexity), true
1218
1219 case "IdentityEdge.node":
1220 if e.complexity.IdentityEdge.Node == nil {
1221 break
1222 }
1223
1224 return e.complexity.IdentityEdge.Node(childComplexity), true
1225
1226 case "Label.color":
1227 if e.complexity.Label.Color == nil {
1228 break
1229 }
1230
1231 return e.complexity.Label.Color(childComplexity), true
1232
1233 case "Label.name":
1234 if e.complexity.Label.Name == nil {
1235 break
1236 }
1237
1238 return e.complexity.Label.Name(childComplexity), true
1239
1240 case "LabelChangeOperation.added":
1241 if e.complexity.LabelChangeOperation.Added == nil {
1242 break
1243 }
1244
1245 return e.complexity.LabelChangeOperation.Added(childComplexity), true
1246
1247 case "LabelChangeOperation.author":
1248 if e.complexity.LabelChangeOperation.Author == nil {
1249 break
1250 }
1251
1252 return e.complexity.LabelChangeOperation.Author(childComplexity), true
1253
1254 case "LabelChangeOperation.date":
1255 if e.complexity.LabelChangeOperation.Date == nil {
1256 break
1257 }
1258
1259 return e.complexity.LabelChangeOperation.Date(childComplexity), true
1260
1261 case "LabelChangeOperation.id":
1262 if e.complexity.LabelChangeOperation.ID == nil {
1263 break
1264 }
1265
1266 return e.complexity.LabelChangeOperation.ID(childComplexity), true
1267
1268 case "LabelChangeOperation.removed":
1269 if e.complexity.LabelChangeOperation.Removed == nil {
1270 break
1271 }
1272
1273 return e.complexity.LabelChangeOperation.Removed(childComplexity), true
1274
1275 case "LabelChangeResult.label":
1276 if e.complexity.LabelChangeResult.Label == nil {
1277 break
1278 }
1279
1280 return e.complexity.LabelChangeResult.Label(childComplexity), true
1281
1282 case "LabelChangeResult.status":
1283 if e.complexity.LabelChangeResult.Status == nil {
1284 break
1285 }
1286
1287 return e.complexity.LabelChangeResult.Status(childComplexity), true
1288
1289 case "LabelChangeTimelineItem.added":
1290 if e.complexity.LabelChangeTimelineItem.Added == nil {
1291 break
1292 }
1293
1294 return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
1295
1296 case "LabelChangeTimelineItem.author":
1297 if e.complexity.LabelChangeTimelineItem.Author == nil {
1298 break
1299 }
1300
1301 return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
1302
1303 case "LabelChangeTimelineItem.date":
1304 if e.complexity.LabelChangeTimelineItem.Date == nil {
1305 break
1306 }
1307
1308 return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
1309
1310 case "LabelChangeTimelineItem.id":
1311 if e.complexity.LabelChangeTimelineItem.ID == nil {
1312 break
1313 }
1314
1315 return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
1316
1317 case "LabelChangeTimelineItem.removed":
1318 if e.complexity.LabelChangeTimelineItem.Removed == nil {
1319 break
1320 }
1321
1322 return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
1323
1324 case "LabelConnection.edges":
1325 if e.complexity.LabelConnection.Edges == nil {
1326 break
1327 }
1328
1329 return e.complexity.LabelConnection.Edges(childComplexity), true
1330
1331 case "LabelConnection.nodes":
1332 if e.complexity.LabelConnection.Nodes == nil {
1333 break
1334 }
1335
1336 return e.complexity.LabelConnection.Nodes(childComplexity), true
1337
1338 case "LabelConnection.pageInfo":
1339 if e.complexity.LabelConnection.PageInfo == nil {
1340 break
1341 }
1342
1343 return e.complexity.LabelConnection.PageInfo(childComplexity), true
1344
1345 case "LabelConnection.totalCount":
1346 if e.complexity.LabelConnection.TotalCount == nil {
1347 break
1348 }
1349
1350 return e.complexity.LabelConnection.TotalCount(childComplexity), true
1351
1352 case "LabelEdge.cursor":
1353 if e.complexity.LabelEdge.Cursor == nil {
1354 break
1355 }
1356
1357 return e.complexity.LabelEdge.Cursor(childComplexity), true
1358
1359 case "LabelEdge.node":
1360 if e.complexity.LabelEdge.Node == nil {
1361 break
1362 }
1363
1364 return e.complexity.LabelEdge.Node(childComplexity), true
1365
1366 case "Mutation.addComment":
1367 if e.complexity.Mutation.AddComment == nil {
1368 break
1369 }
1370
1371 args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
1372 if err != nil {
1373 return 0, false
1374 }
1375
1376 return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
1377
1378 case "Mutation.addCommentAndClose":
1379 if e.complexity.Mutation.AddCommentAndClose == nil {
1380 break
1381 }
1382
1383 args, err := ec.field_Mutation_addCommentAndClose_args(context.TODO(), rawArgs)
1384 if err != nil {
1385 return 0, false
1386 }
1387
1388 return e.complexity.Mutation.AddCommentAndClose(childComplexity, args["input"].(models.AddCommentAndCloseBugInput)), true
1389
1390 case "Mutation.changeLabels":
1391 if e.complexity.Mutation.ChangeLabels == nil {
1392 break
1393 }
1394
1395 args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
1396 if err != nil {
1397 return 0, false
1398 }
1399
1400 return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
1401
1402 case "Mutation.closeBug":
1403 if e.complexity.Mutation.CloseBug == nil {
1404 break
1405 }
1406
1407 args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
1408 if err != nil {
1409 return 0, false
1410 }
1411
1412 return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
1413
1414 case "Mutation.editComment":
1415 if e.complexity.Mutation.EditComment == nil {
1416 break
1417 }
1418
1419 args, err := ec.field_Mutation_editComment_args(context.TODO(), rawArgs)
1420 if err != nil {
1421 return 0, false
1422 }
1423
1424 return e.complexity.Mutation.EditComment(childComplexity, args["input"].(models.EditCommentInput)), true
1425
1426 case "Mutation.newBug":
1427 if e.complexity.Mutation.NewBug == nil {
1428 break
1429 }
1430
1431 args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
1432 if err != nil {
1433 return 0, false
1434 }
1435
1436 return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
1437
1438 case "Mutation.openBug":
1439 if e.complexity.Mutation.OpenBug == nil {
1440 break
1441 }
1442
1443 args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
1444 if err != nil {
1445 return 0, false
1446 }
1447
1448 return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
1449
1450 case "Mutation.setTitle":
1451 if e.complexity.Mutation.SetTitle == nil {
1452 break
1453 }
1454
1455 args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
1456 if err != nil {
1457 return 0, false
1458 }
1459
1460 return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
1461
1462 case "NewBugPayload.bug":
1463 if e.complexity.NewBugPayload.Bug == nil {
1464 break
1465 }
1466
1467 return e.complexity.NewBugPayload.Bug(childComplexity), true
1468
1469 case "NewBugPayload.clientMutationId":
1470 if e.complexity.NewBugPayload.ClientMutationID == nil {
1471 break
1472 }
1473
1474 return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
1475
1476 case "NewBugPayload.operation":
1477 if e.complexity.NewBugPayload.Operation == nil {
1478 break
1479 }
1480
1481 return e.complexity.NewBugPayload.Operation(childComplexity), true
1482
1483 case "OpenBugPayload.bug":
1484 if e.complexity.OpenBugPayload.Bug == nil {
1485 break
1486 }
1487
1488 return e.complexity.OpenBugPayload.Bug(childComplexity), true
1489
1490 case "OpenBugPayload.clientMutationId":
1491 if e.complexity.OpenBugPayload.ClientMutationID == nil {
1492 break
1493 }
1494
1495 return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
1496
1497 case "OpenBugPayload.operation":
1498 if e.complexity.OpenBugPayload.Operation == nil {
1499 break
1500 }
1501
1502 return e.complexity.OpenBugPayload.Operation(childComplexity), true
1503
1504 case "OperationConnection.edges":
1505 if e.complexity.OperationConnection.Edges == nil {
1506 break
1507 }
1508
1509 return e.complexity.OperationConnection.Edges(childComplexity), true
1510
1511 case "OperationConnection.nodes":
1512 if e.complexity.OperationConnection.Nodes == nil {
1513 break
1514 }
1515
1516 return e.complexity.OperationConnection.Nodes(childComplexity), true
1517
1518 case "OperationConnection.pageInfo":
1519 if e.complexity.OperationConnection.PageInfo == nil {
1520 break
1521 }
1522
1523 return e.complexity.OperationConnection.PageInfo(childComplexity), true
1524
1525 case "OperationConnection.totalCount":
1526 if e.complexity.OperationConnection.TotalCount == nil {
1527 break
1528 }
1529
1530 return e.complexity.OperationConnection.TotalCount(childComplexity), true
1531
1532 case "OperationEdge.cursor":
1533 if e.complexity.OperationEdge.Cursor == nil {
1534 break
1535 }
1536
1537 return e.complexity.OperationEdge.Cursor(childComplexity), true
1538
1539 case "OperationEdge.node":
1540 if e.complexity.OperationEdge.Node == nil {
1541 break
1542 }
1543
1544 return e.complexity.OperationEdge.Node(childComplexity), true
1545
1546 case "PageInfo.endCursor":
1547 if e.complexity.PageInfo.EndCursor == nil {
1548 break
1549 }
1550
1551 return e.complexity.PageInfo.EndCursor(childComplexity), true
1552
1553 case "PageInfo.hasNextPage":
1554 if e.complexity.PageInfo.HasNextPage == nil {
1555 break
1556 }
1557
1558 return e.complexity.PageInfo.HasNextPage(childComplexity), true
1559
1560 case "PageInfo.hasPreviousPage":
1561 if e.complexity.PageInfo.HasPreviousPage == nil {
1562 break
1563 }
1564
1565 return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
1566
1567 case "PageInfo.startCursor":
1568 if e.complexity.PageInfo.StartCursor == nil {
1569 break
1570 }
1571
1572 return e.complexity.PageInfo.StartCursor(childComplexity), true
1573
1574 case "Query.repository":
1575 if e.complexity.Query.Repository == nil {
1576 break
1577 }
1578
1579 args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
1580 if err != nil {
1581 return 0, false
1582 }
1583
1584 return e.complexity.Query.Repository(childComplexity, args["ref"].(*string)), true
1585
1586 case "Repository.allBugs":
1587 if e.complexity.Repository.AllBugs == nil {
1588 break
1589 }
1590
1591 args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
1592 if err != nil {
1593 return 0, false
1594 }
1595
1596 return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
1597
1598 case "Repository.allIdentities":
1599 if e.complexity.Repository.AllIdentities == nil {
1600 break
1601 }
1602
1603 args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
1604 if err != nil {
1605 return 0, false
1606 }
1607
1608 return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1609
1610 case "Repository.bug":
1611 if e.complexity.Repository.Bug == nil {
1612 break
1613 }
1614
1615 args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
1616 if err != nil {
1617 return 0, false
1618 }
1619
1620 return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
1621
1622 case "Repository.identity":
1623 if e.complexity.Repository.Identity == nil {
1624 break
1625 }
1626
1627 args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
1628 if err != nil {
1629 return 0, false
1630 }
1631
1632 return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
1633
1634 case "Repository.name":
1635 if e.complexity.Repository.Name == nil {
1636 break
1637 }
1638
1639 return e.complexity.Repository.Name(childComplexity), true
1640
1641 case "Repository.userIdentity":
1642 if e.complexity.Repository.UserIdentity == nil {
1643 break
1644 }
1645
1646 return e.complexity.Repository.UserIdentity(childComplexity), true
1647
1648 case "Repository.validLabels":
1649 if e.complexity.Repository.ValidLabels == nil {
1650 break
1651 }
1652
1653 args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
1654 if err != nil {
1655 return 0, false
1656 }
1657
1658 return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1659
1660 case "SetStatusOperation.author":
1661 if e.complexity.SetStatusOperation.Author == nil {
1662 break
1663 }
1664
1665 return e.complexity.SetStatusOperation.Author(childComplexity), true
1666
1667 case "SetStatusOperation.date":
1668 if e.complexity.SetStatusOperation.Date == nil {
1669 break
1670 }
1671
1672 return e.complexity.SetStatusOperation.Date(childComplexity), true
1673
1674 case "SetStatusOperation.id":
1675 if e.complexity.SetStatusOperation.ID == nil {
1676 break
1677 }
1678
1679 return e.complexity.SetStatusOperation.ID(childComplexity), true
1680
1681 case "SetStatusOperation.status":
1682 if e.complexity.SetStatusOperation.Status == nil {
1683 break
1684 }
1685
1686 return e.complexity.SetStatusOperation.Status(childComplexity), true
1687
1688 case "SetStatusTimelineItem.author":
1689 if e.complexity.SetStatusTimelineItem.Author == nil {
1690 break
1691 }
1692
1693 return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
1694
1695 case "SetStatusTimelineItem.date":
1696 if e.complexity.SetStatusTimelineItem.Date == nil {
1697 break
1698 }
1699
1700 return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
1701
1702 case "SetStatusTimelineItem.id":
1703 if e.complexity.SetStatusTimelineItem.ID == nil {
1704 break
1705 }
1706
1707 return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
1708
1709 case "SetStatusTimelineItem.status":
1710 if e.complexity.SetStatusTimelineItem.Status == nil {
1711 break
1712 }
1713
1714 return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
1715
1716 case "SetTitleOperation.author":
1717 if e.complexity.SetTitleOperation.Author == nil {
1718 break
1719 }
1720
1721 return e.complexity.SetTitleOperation.Author(childComplexity), true
1722
1723 case "SetTitleOperation.date":
1724 if e.complexity.SetTitleOperation.Date == nil {
1725 break
1726 }
1727
1728 return e.complexity.SetTitleOperation.Date(childComplexity), true
1729
1730 case "SetTitleOperation.id":
1731 if e.complexity.SetTitleOperation.ID == nil {
1732 break
1733 }
1734
1735 return e.complexity.SetTitleOperation.ID(childComplexity), true
1736
1737 case "SetTitleOperation.title":
1738 if e.complexity.SetTitleOperation.Title == nil {
1739 break
1740 }
1741
1742 return e.complexity.SetTitleOperation.Title(childComplexity), true
1743
1744 case "SetTitleOperation.was":
1745 if e.complexity.SetTitleOperation.Was == nil {
1746 break
1747 }
1748
1749 return e.complexity.SetTitleOperation.Was(childComplexity), true
1750
1751 case "SetTitlePayload.bug":
1752 if e.complexity.SetTitlePayload.Bug == nil {
1753 break
1754 }
1755
1756 return e.complexity.SetTitlePayload.Bug(childComplexity), true
1757
1758 case "SetTitlePayload.clientMutationId":
1759 if e.complexity.SetTitlePayload.ClientMutationID == nil {
1760 break
1761 }
1762
1763 return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
1764
1765 case "SetTitlePayload.operation":
1766 if e.complexity.SetTitlePayload.Operation == nil {
1767 break
1768 }
1769
1770 return e.complexity.SetTitlePayload.Operation(childComplexity), true
1771
1772 case "SetTitleTimelineItem.author":
1773 if e.complexity.SetTitleTimelineItem.Author == nil {
1774 break
1775 }
1776
1777 return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
1778
1779 case "SetTitleTimelineItem.date":
1780 if e.complexity.SetTitleTimelineItem.Date == nil {
1781 break
1782 }
1783
1784 return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
1785
1786 case "SetTitleTimelineItem.id":
1787 if e.complexity.SetTitleTimelineItem.ID == nil {
1788 break
1789 }
1790
1791 return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
1792
1793 case "SetTitleTimelineItem.title":
1794 if e.complexity.SetTitleTimelineItem.Title == nil {
1795 break
1796 }
1797
1798 return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
1799
1800 case "SetTitleTimelineItem.was":
1801 if e.complexity.SetTitleTimelineItem.Was == nil {
1802 break
1803 }
1804
1805 return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
1806
1807 case "TimelineItemConnection.edges":
1808 if e.complexity.TimelineItemConnection.Edges == nil {
1809 break
1810 }
1811
1812 return e.complexity.TimelineItemConnection.Edges(childComplexity), true
1813
1814 case "TimelineItemConnection.nodes":
1815 if e.complexity.TimelineItemConnection.Nodes == nil {
1816 break
1817 }
1818
1819 return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
1820
1821 case "TimelineItemConnection.pageInfo":
1822 if e.complexity.TimelineItemConnection.PageInfo == nil {
1823 break
1824 }
1825
1826 return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
1827
1828 case "TimelineItemConnection.totalCount":
1829 if e.complexity.TimelineItemConnection.TotalCount == nil {
1830 break
1831 }
1832
1833 return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
1834
1835 case "TimelineItemEdge.cursor":
1836 if e.complexity.TimelineItemEdge.Cursor == nil {
1837 break
1838 }
1839
1840 return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
1841
1842 case "TimelineItemEdge.node":
1843 if e.complexity.TimelineItemEdge.Node == nil {
1844 break
1845 }
1846
1847 return e.complexity.TimelineItemEdge.Node(childComplexity), true
1848
1849 }
1850 return 0, false
1851}
1852
1853func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
1854 rc := graphql.GetOperationContext(ctx)
1855 ec := executionContext{rc, e}
1856 first := true
1857
1858 switch rc.Operation.Operation {
1859 case ast.Query:
1860 return func(ctx context.Context) *graphql.Response {
1861 if !first {
1862 return nil
1863 }
1864 first = false
1865 data := ec._Query(ctx, rc.Operation.SelectionSet)
1866 var buf bytes.Buffer
1867 data.MarshalGQL(&buf)
1868
1869 return &graphql.Response{
1870 Data: buf.Bytes(),
1871 }
1872 }
1873 case ast.Mutation:
1874 return func(ctx context.Context) *graphql.Response {
1875 if !first {
1876 return nil
1877 }
1878 first = false
1879 data := ec._Mutation(ctx, rc.Operation.SelectionSet)
1880 var buf bytes.Buffer
1881 data.MarshalGQL(&buf)
1882
1883 return &graphql.Response{
1884 Data: buf.Bytes(),
1885 }
1886 }
1887
1888 default:
1889 return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
1890 }
1891}
1892
1893type executionContext struct {
1894 *graphql.OperationContext
1895 *executableSchema
1896}
1897
1898func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
1899 if ec.DisableIntrospection {
1900 return nil, errors.New("introspection disabled")
1901 }
1902 return introspection.WrapSchema(parsedSchema), nil
1903}
1904
1905func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
1906 if ec.DisableIntrospection {
1907 return nil, errors.New("introspection disabled")
1908 }
1909 return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
1910}
1911
1912var sources = []*ast.Source{
1913 &ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
1914type Comment implements Authored {
1915 """The author of this comment."""
1916 author: Identity!
1917
1918 """The message of this comment."""
1919 message: String!
1920
1921 """All media's hash referenced in this comment"""
1922 files: [Hash!]!
1923}
1924
1925type CommentConnection {
1926 edges: [CommentEdge!]!
1927 nodes: [Comment!]!
1928 pageInfo: PageInfo!
1929 totalCount: Int!
1930}
1931
1932type CommentEdge {
1933 cursor: String!
1934 node: Comment!
1935}
1936
1937enum Status {
1938 OPEN
1939 CLOSED
1940}
1941
1942type Bug implements Authored {
1943 """The identifier for this bug"""
1944 id: String!
1945 """The human version (truncated) identifier for this bug"""
1946 humanId: String!
1947 status: Status!
1948 title: String!
1949 labels: [Label!]!
1950 author: Identity!
1951 createdAt: Time!
1952 lastEdit: Time!
1953
1954 """The actors of the bug. Actors are Identity that have interacted with the bug."""
1955 actors(
1956 """Returns the elements in the list that come after the specified cursor."""
1957 after: String
1958 """Returns the elements in the list that come before the specified cursor."""
1959 before: String
1960 """Returns the first _n_ elements from the list."""
1961 first: Int
1962 """Returns the last _n_ elements from the list."""
1963 last: Int
1964 ): IdentityConnection!
1965
1966 """The participants of the bug. Participants are Identity that have created or
1967 added a comment on the bug."""
1968 participants(
1969 """Returns the elements in the list that come after the specified cursor."""
1970 after: String
1971 """Returns the elements in the list that come before the specified cursor."""
1972 before: String
1973 """Returns the first _n_ elements from the list."""
1974 first: Int
1975 """Returns the last _n_ elements from the list."""
1976 last: Int
1977 ): IdentityConnection!
1978
1979 comments(
1980 """Returns the elements in the list that come after the specified cursor."""
1981 after: String
1982 """Returns the elements in the list that come before the specified cursor."""
1983 before: String
1984 """Returns the first _n_ elements from the list."""
1985 first: Int
1986 """Returns the last _n_ elements from the list."""
1987 last: Int
1988 ): CommentConnection!
1989
1990 timeline(
1991 """Returns the elements in the list that come after the specified cursor."""
1992 after: String
1993 """Returns the elements in the list that come before the specified cursor."""
1994 before: String
1995 """Returns the first _n_ elements from the list."""
1996 first: Int
1997 """Returns the last _n_ elements from the list."""
1998 last: Int
1999 ): TimelineItemConnection!
2000
2001 operations(
2002 """Returns the elements in the list that come after the specified cursor."""
2003 after: String
2004 """Returns the elements in the list that come before the specified cursor."""
2005 before: String
2006 """Returns the first _n_ elements from the list."""
2007 first: Int
2008 """Returns the last _n_ elements from the list."""
2009 last: Int
2010 ): OperationConnection!
2011}
2012
2013"""The connection type for Bug."""
2014type BugConnection {
2015 """A list of edges."""
2016 edges: [BugEdge!]!
2017 nodes: [Bug!]!
2018 """Information to aid in pagination."""
2019 pageInfo: PageInfo!
2020 """Identifies the total count of items in the connection."""
2021 totalCount: Int!
2022}
2023
2024"""An edge in a connection."""
2025type BugEdge {
2026 """A cursor for use in pagination."""
2027 cursor: String!
2028 """The item at the end of the edge."""
2029 node: Bug!
2030}
2031`, BuiltIn: false},
2032 &ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
2033type Identity {
2034 """The identifier for this identity"""
2035 id: String!
2036 """The human version (truncated) identifier for this identity"""
2037 humanId: String!
2038 """The name of the person, if known."""
2039 name: String
2040 """The email of the person, if known."""
2041 email: String
2042 """The login of the person, if known."""
2043 login: String
2044 """A non-empty string to display, representing the identity, based on the non-empty values."""
2045 displayName: String!
2046 """An url to an avatar"""
2047 avatarUrl: String
2048 """isProtected is true if the chain of git commits started to be signed.
2049 If that's the case, only signed commit with a valid key for this identity can be added."""
2050 isProtected: Boolean!
2051}
2052
2053type IdentityConnection {
2054 edges: [IdentityEdge!]!
2055 nodes: [Identity!]!
2056 pageInfo: PageInfo!
2057 totalCount: Int!
2058}
2059
2060type IdentityEdge {
2061 cursor: String!
2062 node: Identity!
2063}`, BuiltIn: false},
2064 &ast.Source{Name: "schema/label.graphql", Input: `"""Label for a bug."""
2065type Label {
2066 """The name of the label."""
2067 name: String!
2068 """Color of the label."""
2069 color: Color!
2070}
2071
2072type LabelConnection {
2073 edges: [LabelEdge!]!
2074 nodes: [Label!]!
2075 pageInfo: PageInfo!
2076 totalCount: Int!
2077}
2078
2079type LabelEdge {
2080 cursor: String!
2081 node: Label!
2082}`, BuiltIn: false},
2083 &ast.Source{Name: "schema/mutations.graphql", Input: `input NewBugInput {
2084 """A unique identifier for the client performing the mutation."""
2085 clientMutationId: String
2086 """The name of the repository. If not set, the default repository is used."""
2087 repoRef: String
2088 """The title of the new bug."""
2089 title: String!
2090 """The first message of the new bug."""
2091 message: String!
2092 """The collection of file's hash required for the first message."""
2093 files: [Hash!]
2094}
2095
2096type NewBugPayload {
2097 """A unique identifier for the client performing the mutation."""
2098 clientMutationId: String
2099 """The created bug."""
2100 bug: Bug!
2101 """The resulting operation."""
2102 operation: CreateOperation!
2103}
2104
2105input AddCommentInput {
2106 """A unique identifier for the client performing the mutation."""
2107 clientMutationId: String
2108 """The name of the repository. If not set, the default repository is used."""
2109 repoRef: String
2110 """The bug ID's prefix."""
2111 prefix: String!
2112 """The message to be added to the bug."""
2113 message: String!
2114 """The collection of file's hash required for the first message."""
2115 files: [Hash!]
2116}
2117
2118type AddCommentPayload {
2119 """A unique identifier for the client performing the mutation."""
2120 clientMutationId: String
2121 """The affected bug."""
2122 bug: Bug!
2123 """The resulting operation."""
2124 operation: AddCommentOperation!
2125}
2126
2127input AddCommentAndCloseBugInput {
2128 """A unique identifier for the client performing the mutation."""
2129 clientMutationId: String
2130 """The name of the repository. If not set, the default repository is used."""
2131 repoRef: String
2132 """The bug ID's prefix."""
2133 prefix: String!
2134 """The message to be added to the bug."""
2135 message: String!
2136 """The collection of file's hash required for the first message."""
2137 files: [Hash!]
2138}
2139
2140type AddCommentAndCloseBugPayload {
2141 """A unique identifier for the client performing the mutation."""
2142 clientMutationId: String
2143 """The affected bug."""
2144 bug: Bug!
2145 """The resulting AddComment operation."""
2146 commentOperation: AddCommentOperation!
2147 """The resulting SetStatusOperation."""
2148 statusOperation: SetStatusOperation!
2149}
2150
2151input EditCommentInput {
2152 """A unique identifier for the client performing the mutation."""
2153 clientMutationId: String
2154 """The name of the repository. If not set, the default repository is used."""
2155 repoRef: String
2156 """The bug ID's prefix."""
2157 prefix: String!
2158 """The ID of the comment to be changed."""
2159 target: String!
2160 """The new message to be set."""
2161 message: String!
2162 """The collection of file's hash required for the first message."""
2163 files: [Hash!]
2164}
2165
2166type EditCommentPayload {
2167 """A unique identifier for the client performing the mutation."""
2168 clientMutationId: String
2169 """The affected bug."""
2170 bug: Bug!
2171 """The resulting operation."""
2172 operation: EditCommentOperation!
2173}
2174
2175input ChangeLabelInput {
2176 """A unique identifier for the client performing the mutation."""
2177 clientMutationId: String
2178 """The name of the repository. If not set, the default repository is used."""
2179 repoRef: String
2180 """The bug ID's prefix."""
2181 prefix: String!
2182 """The list of label to add."""
2183 added: [String!]
2184 """The list of label to remove."""
2185 Removed: [String!]
2186}
2187
2188enum LabelChangeStatus {
2189 ADDED
2190 REMOVED
2191 DUPLICATE_IN_OP
2192 ALREADY_EXIST
2193 DOESNT_EXIST
2194}
2195
2196type LabelChangeResult {
2197 """The source label."""
2198 label: Label!
2199 """The effect this label had."""
2200 status: LabelChangeStatus!
2201}
2202
2203type ChangeLabelPayload {
2204 """A unique identifier for the client performing the mutation."""
2205 clientMutationId: String
2206 """The affected bug."""
2207 bug: Bug!
2208 """The resulting operation."""
2209 operation: LabelChangeOperation!
2210 """The effect each source label had."""
2211 results: [LabelChangeResult]!
2212}
2213
2214input OpenBugInput {
2215 """A unique identifier for the client performing the mutation."""
2216 clientMutationId: String
2217 """The name of the repository. If not set, the default repository is used."""
2218 repoRef: String
2219 """The bug ID's prefix."""
2220 prefix: String!
2221}
2222
2223type OpenBugPayload {
2224 """A unique identifier for the client performing the mutation."""
2225 clientMutationId: String
2226 """The affected bug."""
2227 bug: Bug!
2228 """The resulting operation."""
2229 operation: SetStatusOperation!
2230}
2231
2232input CloseBugInput {
2233 """A unique identifier for the client performing the mutation."""
2234 clientMutationId: String
2235 """The name of the repository. If not set, the default repository is used."""
2236 repoRef: String
2237 """The bug ID's prefix."""
2238 prefix: String!
2239}
2240
2241type CloseBugPayload {
2242 """A unique identifier for the client performing the mutation."""
2243 clientMutationId: String
2244 """The affected bug."""
2245 bug: Bug!
2246 """The resulting operation."""
2247 operation: SetStatusOperation!
2248}
2249
2250input SetTitleInput {
2251 """A unique identifier for the client performing the mutation."""
2252 clientMutationId: String
2253 """The name of the repository. If not set, the default repository is used."""
2254 repoRef: String
2255 """The bug ID's prefix."""
2256 prefix: String!
2257 """The new title."""
2258 title: String!
2259}
2260
2261type SetTitlePayload {
2262 """A unique identifier for the client performing the mutation."""
2263 clientMutationId: String
2264 """The affected bug."""
2265 bug: Bug!
2266 """The resulting operation"""
2267 operation: SetTitleOperation!
2268}
2269`, BuiltIn: false},
2270 &ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
2271interface Operation {
2272 """The identifier of the operation"""
2273 id: String!
2274 """The operations author."""
2275 author: Identity!
2276 """The datetime when this operation was issued."""
2277 date: Time!
2278}
2279
2280# Connection
2281
2282"""The connection type for an Operation"""
2283type OperationConnection {
2284 edges: [OperationEdge!]!
2285 nodes: [Operation!]!
2286 pageInfo: PageInfo!
2287 totalCount: Int!
2288}
2289
2290"""Represent an Operation"""
2291type OperationEdge {
2292 cursor: String!
2293 node: Operation!
2294}
2295
2296# Operations
2297
2298type CreateOperation 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 title: String!
2307 message: String!
2308 files: [Hash!]!
2309}
2310
2311type SetTitleOperation implements Operation & Authored {
2312 """The identifier of the operation"""
2313 id: String!
2314 """The author of this object."""
2315 author: Identity!
2316 """The datetime when this operation was issued."""
2317 date: Time!
2318
2319 title: String!
2320 was: String!
2321}
2322
2323type AddCommentOperation implements Operation & Authored {
2324 """The identifier of the operation"""
2325 id: String!
2326 """The author of this object."""
2327 author: Identity!
2328 """The datetime when this operation was issued."""
2329 date: Time!
2330
2331 message: String!
2332 files: [Hash!]!
2333}
2334
2335type EditCommentOperation implements Operation & Authored {
2336 """The identifier of the operation"""
2337 id: String!
2338 """The author of this object."""
2339 author: Identity!
2340 """The datetime when this operation was issued."""
2341 date: Time!
2342
2343 target: String!
2344 message: String!
2345 files: [Hash!]!
2346}
2347
2348type SetStatusOperation implements Operation & Authored {
2349 """The identifier of the operation"""
2350 id: String!
2351 """The author of this object."""
2352 author: Identity!
2353 """The datetime when this operation was issued."""
2354 date: Time!
2355
2356 status: Status!
2357}
2358
2359type LabelChangeOperation implements Operation & Authored {
2360 """The identifier of the operation"""
2361 id: String!
2362 """The author of this object."""
2363 author: Identity!
2364 """The datetime when this operation was issued."""
2365 date: Time!
2366
2367 added: [Label!]!
2368 removed: [Label!]!
2369}
2370`, BuiltIn: false},
2371 &ast.Source{Name: "schema/repository.graphql", Input: `
2372type Repository {
2373 """The name of the repository"""
2374 name: String
2375
2376 """All the bugs"""
2377 allBugs(
2378 """Returns the elements in the list that come after the specified cursor."""
2379 after: String
2380 """Returns the elements in the list that come before the specified cursor."""
2381 before: String
2382 """Returns the first _n_ elements from the list."""
2383 first: Int
2384 """Returns the last _n_ elements from the list."""
2385 last: Int
2386 """A query to select and order bugs."""
2387 query: String
2388 ): BugConnection!
2389
2390 bug(prefix: String!): Bug
2391
2392 """All the identities"""
2393 allIdentities(
2394 """Returns the elements in the list that come after the specified cursor."""
2395 after: String
2396 """Returns the elements in the list that come before the specified cursor."""
2397 before: String
2398 """Returns the first _n_ elements from the list."""
2399 first: Int
2400 """Returns the last _n_ elements from the list."""
2401 last: Int
2402 ): IdentityConnection!
2403
2404 identity(prefix: String!): Identity
2405
2406 """The identity created or selected by the user as its own"""
2407 userIdentity: Identity
2408
2409 """List of valid labels."""
2410 validLabels(
2411 """Returns the elements in the list that come after the specified cursor."""
2412 after: String
2413 """Returns the elements in the list that come before the specified cursor."""
2414 before: String
2415 """Returns the first _n_ elements from the list."""
2416 first: Int
2417 """Returns the last _n_ elements from the list."""
2418 last: Int
2419 ): LabelConnection!
2420}
2421`, BuiltIn: false},
2422 &ast.Source{Name: "schema/root.graphql", Input: `type Query {
2423 """Access a repository by reference/name. If no ref is given, the default repository is returned if any."""
2424 repository(ref: String): Repository
2425}
2426
2427type Mutation {
2428 """Create a new bug"""
2429 newBug(input: NewBugInput!): NewBugPayload!
2430 """Add a new comment to a bug"""
2431 addComment(input: AddCommentInput!): AddCommentPayload!
2432 """Add a new comment to a bug and close it"""
2433 addCommentAndClose(input: AddCommentAndCloseBugInput!): AddCommentAndCloseBugPayload!
2434 """Change a comment of a bug"""
2435 editComment(input: EditCommentInput!): EditCommentPayload!
2436 """Add or remove a set of label on a bug"""
2437 changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
2438 """Change a bug's status to open"""
2439 openBug(input: OpenBugInput!): OpenBugPayload!
2440 """Change a bug's status to closed"""
2441 closeBug(input: CloseBugInput!): CloseBugPayload!
2442 """Change a bug's title"""
2443 setTitle(input: SetTitleInput!): SetTitlePayload!
2444}
2445`, BuiltIn: false},
2446 &ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
2447interface TimelineItem {
2448 """The identifier of the source operation"""
2449 id: String!
2450}
2451
2452"""CommentHistoryStep hold one version of a message in the history"""
2453type CommentHistoryStep {
2454 message: String!
2455 date: Time!
2456}
2457
2458# Connection
2459
2460"""The connection type for TimelineItem"""
2461type TimelineItemConnection {
2462 edges: [TimelineItemEdge!]!
2463 nodes: [TimelineItem!]!
2464 pageInfo: PageInfo!
2465 totalCount: Int!
2466}
2467
2468"""Represent a TimelineItem"""
2469type TimelineItemEdge {
2470 cursor: String!
2471 node: TimelineItem!
2472}
2473
2474# Items
2475
2476"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
2477type CreateTimelineItem implements TimelineItem & Authored {
2478 """The identifier of the source operation"""
2479 id: String!
2480 author: Identity!
2481 message: String!
2482 messageIsEmpty: Boolean!
2483 files: [Hash!]!
2484 createdAt: Time!
2485 lastEdit: Time!
2486 edited: Boolean!
2487 history: [CommentHistoryStep!]!
2488}
2489
2490"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
2491type AddCommentTimelineItem implements TimelineItem & Authored {
2492 """The identifier of the source operation"""
2493 id: String!
2494 author: Identity!
2495 message: String!
2496 messageIsEmpty: Boolean!
2497 files: [Hash!]!
2498 createdAt: Time!
2499 lastEdit: Time!
2500 edited: Boolean!
2501 history: [CommentHistoryStep!]!
2502}
2503
2504"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
2505type LabelChangeTimelineItem implements TimelineItem & Authored {
2506 """The identifier of the source operation"""
2507 id: String!
2508 author: Identity!
2509 date: Time!
2510 added: [Label!]!
2511 removed: [Label!]!
2512}
2513
2514"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
2515type SetStatusTimelineItem implements TimelineItem & Authored {
2516 """The identifier of the source operation"""
2517 id: String!
2518 author: Identity!
2519 date: Time!
2520 status: Status!
2521}
2522
2523"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
2524type SetTitleTimelineItem implements TimelineItem & Authored {
2525 """The identifier of the source operation"""
2526 id: String!
2527 author: Identity!
2528 date: Time!
2529 title: String!
2530 was: String!
2531}
2532`, BuiltIn: false},
2533 &ast.Source{Name: "schema/types.graphql", Input: `scalar Time
2534scalar Hash
2535
2536"""Defines a color by red, green and blue components."""
2537type Color {
2538 """Red component of the color."""
2539 R: Int!
2540 """Green component of the color."""
2541 G: Int!
2542 """Blue component of the color."""
2543 B: Int!
2544}
2545
2546"""Information about pagination in a connection."""
2547type PageInfo {
2548 """When paginating forwards, are there more items?"""
2549 hasNextPage: Boolean!
2550 """When paginating backwards, are there more items?"""
2551 hasPreviousPage: Boolean!
2552 """When paginating backwards, the cursor to continue."""
2553 startCursor: String!
2554 """When paginating forwards, the cursor to continue."""
2555 endCursor: String!
2556}
2557
2558"""An object that has an author."""
2559interface Authored {
2560 """The author of this object."""
2561 author: Identity!
2562}
2563`, BuiltIn: false},
2564}
2565var parsedSchema = gqlparser.MustLoadSchema(sources...)
2566
2567// endregion ************************** generated!.gotpl **************************
2568
2569// region ***************************** args.gotpl *****************************
2570
2571func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2572 var err error
2573 args := map[string]interface{}{}
2574 var arg0 *string
2575 if tmp, ok := rawArgs["after"]; ok {
2576 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2577 if err != nil {
2578 return nil, err
2579 }
2580 }
2581 args["after"] = arg0
2582 var arg1 *string
2583 if tmp, ok := rawArgs["before"]; ok {
2584 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2585 if err != nil {
2586 return nil, err
2587 }
2588 }
2589 args["before"] = arg1
2590 var arg2 *int
2591 if tmp, ok := rawArgs["first"]; ok {
2592 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2593 if err != nil {
2594 return nil, err
2595 }
2596 }
2597 args["first"] = arg2
2598 var arg3 *int
2599 if tmp, ok := rawArgs["last"]; ok {
2600 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2601 if err != nil {
2602 return nil, err
2603 }
2604 }
2605 args["last"] = arg3
2606 return args, nil
2607}
2608
2609func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2610 var err error
2611 args := map[string]interface{}{}
2612 var arg0 *string
2613 if tmp, ok := rawArgs["after"]; ok {
2614 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2615 if err != nil {
2616 return nil, err
2617 }
2618 }
2619 args["after"] = arg0
2620 var arg1 *string
2621 if tmp, ok := rawArgs["before"]; ok {
2622 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2623 if err != nil {
2624 return nil, err
2625 }
2626 }
2627 args["before"] = arg1
2628 var arg2 *int
2629 if tmp, ok := rawArgs["first"]; ok {
2630 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2631 if err != nil {
2632 return nil, err
2633 }
2634 }
2635 args["first"] = arg2
2636 var arg3 *int
2637 if tmp, ok := rawArgs["last"]; ok {
2638 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2639 if err != nil {
2640 return nil, err
2641 }
2642 }
2643 args["last"] = arg3
2644 return args, nil
2645}
2646
2647func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2648 var err error
2649 args := map[string]interface{}{}
2650 var arg0 *string
2651 if tmp, ok := rawArgs["after"]; ok {
2652 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2653 if err != nil {
2654 return nil, err
2655 }
2656 }
2657 args["after"] = arg0
2658 var arg1 *string
2659 if tmp, ok := rawArgs["before"]; ok {
2660 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2661 if err != nil {
2662 return nil, err
2663 }
2664 }
2665 args["before"] = arg1
2666 var arg2 *int
2667 if tmp, ok := rawArgs["first"]; ok {
2668 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2669 if err != nil {
2670 return nil, err
2671 }
2672 }
2673 args["first"] = arg2
2674 var arg3 *int
2675 if tmp, ok := rawArgs["last"]; ok {
2676 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2677 if err != nil {
2678 return nil, err
2679 }
2680 }
2681 args["last"] = arg3
2682 return args, nil
2683}
2684
2685func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2686 var err error
2687 args := map[string]interface{}{}
2688 var arg0 *string
2689 if tmp, ok := rawArgs["after"]; ok {
2690 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2691 if err != nil {
2692 return nil, err
2693 }
2694 }
2695 args["after"] = arg0
2696 var arg1 *string
2697 if tmp, ok := rawArgs["before"]; ok {
2698 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2699 if err != nil {
2700 return nil, err
2701 }
2702 }
2703 args["before"] = arg1
2704 var arg2 *int
2705 if tmp, ok := rawArgs["first"]; ok {
2706 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2707 if err != nil {
2708 return nil, err
2709 }
2710 }
2711 args["first"] = arg2
2712 var arg3 *int
2713 if tmp, ok := rawArgs["last"]; ok {
2714 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2715 if err != nil {
2716 return nil, err
2717 }
2718 }
2719 args["last"] = arg3
2720 return args, nil
2721}
2722
2723func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2724 var err error
2725 args := map[string]interface{}{}
2726 var arg0 *string
2727 if tmp, ok := rawArgs["after"]; ok {
2728 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2729 if err != nil {
2730 return nil, err
2731 }
2732 }
2733 args["after"] = arg0
2734 var arg1 *string
2735 if tmp, ok := rawArgs["before"]; ok {
2736 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2737 if err != nil {
2738 return nil, err
2739 }
2740 }
2741 args["before"] = arg1
2742 var arg2 *int
2743 if tmp, ok := rawArgs["first"]; ok {
2744 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2745 if err != nil {
2746 return nil, err
2747 }
2748 }
2749 args["first"] = arg2
2750 var arg3 *int
2751 if tmp, ok := rawArgs["last"]; ok {
2752 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2753 if err != nil {
2754 return nil, err
2755 }
2756 }
2757 args["last"] = arg3
2758 return args, nil
2759}
2760
2761func (ec *executionContext) field_Mutation_addCommentAndClose_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2762 var err error
2763 args := map[string]interface{}{}
2764 var arg0 models.AddCommentAndCloseBugInput
2765 if tmp, ok := rawArgs["input"]; ok {
2766 arg0, err = ec.unmarshalNAddCommentAndCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugInput(ctx, tmp)
2767 if err != nil {
2768 return nil, err
2769 }
2770 }
2771 args["input"] = arg0
2772 return args, nil
2773}
2774
2775func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2776 var err error
2777 args := map[string]interface{}{}
2778 var arg0 models.AddCommentInput
2779 if tmp, ok := rawArgs["input"]; ok {
2780 arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
2781 if err != nil {
2782 return nil, err
2783 }
2784 }
2785 args["input"] = arg0
2786 return args, nil
2787}
2788
2789func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2790 var err error
2791 args := map[string]interface{}{}
2792 var arg0 *models.ChangeLabelInput
2793 if tmp, ok := rawArgs["input"]; ok {
2794 arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
2795 if err != nil {
2796 return nil, err
2797 }
2798 }
2799 args["input"] = arg0
2800 return args, nil
2801}
2802
2803func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2804 var err error
2805 args := map[string]interface{}{}
2806 var arg0 models.CloseBugInput
2807 if tmp, ok := rawArgs["input"]; ok {
2808 arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
2809 if err != nil {
2810 return nil, err
2811 }
2812 }
2813 args["input"] = arg0
2814 return args, nil
2815}
2816
2817func (ec *executionContext) field_Mutation_editComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2818 var err error
2819 args := map[string]interface{}{}
2820 var arg0 models.EditCommentInput
2821 if tmp, ok := rawArgs["input"]; ok {
2822 arg0, err = ec.unmarshalNEditCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx, tmp)
2823 if err != nil {
2824 return nil, err
2825 }
2826 }
2827 args["input"] = arg0
2828 return args, nil
2829}
2830
2831func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2832 var err error
2833 args := map[string]interface{}{}
2834 var arg0 models.NewBugInput
2835 if tmp, ok := rawArgs["input"]; ok {
2836 arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
2837 if err != nil {
2838 return nil, err
2839 }
2840 }
2841 args["input"] = arg0
2842 return args, nil
2843}
2844
2845func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2846 var err error
2847 args := map[string]interface{}{}
2848 var arg0 models.OpenBugInput
2849 if tmp, ok := rawArgs["input"]; ok {
2850 arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
2851 if err != nil {
2852 return nil, err
2853 }
2854 }
2855 args["input"] = arg0
2856 return args, nil
2857}
2858
2859func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2860 var err error
2861 args := map[string]interface{}{}
2862 var arg0 models.SetTitleInput
2863 if tmp, ok := rawArgs["input"]; ok {
2864 arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
2865 if err != nil {
2866 return nil, err
2867 }
2868 }
2869 args["input"] = arg0
2870 return args, nil
2871}
2872
2873func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2874 var err error
2875 args := map[string]interface{}{}
2876 var arg0 string
2877 if tmp, ok := rawArgs["name"]; ok {
2878 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2879 if err != nil {
2880 return nil, err
2881 }
2882 }
2883 args["name"] = arg0
2884 return args, nil
2885}
2886
2887func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2888 var err error
2889 args := map[string]interface{}{}
2890 var arg0 *string
2891 if tmp, ok := rawArgs["ref"]; ok {
2892 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2893 if err != nil {
2894 return nil, err
2895 }
2896 }
2897 args["ref"] = arg0
2898 return args, nil
2899}
2900
2901func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2902 var err error
2903 args := map[string]interface{}{}
2904 var arg0 *string
2905 if tmp, ok := rawArgs["after"]; ok {
2906 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2907 if err != nil {
2908 return nil, err
2909 }
2910 }
2911 args["after"] = arg0
2912 var arg1 *string
2913 if tmp, ok := rawArgs["before"]; ok {
2914 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2915 if err != nil {
2916 return nil, err
2917 }
2918 }
2919 args["before"] = arg1
2920 var arg2 *int
2921 if tmp, ok := rawArgs["first"]; ok {
2922 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2923 if err != nil {
2924 return nil, err
2925 }
2926 }
2927 args["first"] = arg2
2928 var arg3 *int
2929 if tmp, ok := rawArgs["last"]; ok {
2930 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2931 if err != nil {
2932 return nil, err
2933 }
2934 }
2935 args["last"] = arg3
2936 var arg4 *string
2937 if tmp, ok := rawArgs["query"]; ok {
2938 arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2939 if err != nil {
2940 return nil, err
2941 }
2942 }
2943 args["query"] = arg4
2944 return args, nil
2945}
2946
2947func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2948 var err error
2949 args := map[string]interface{}{}
2950 var arg0 *string
2951 if tmp, ok := rawArgs["after"]; ok {
2952 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2953 if err != nil {
2954 return nil, err
2955 }
2956 }
2957 args["after"] = arg0
2958 var arg1 *string
2959 if tmp, ok := rawArgs["before"]; ok {
2960 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2961 if err != nil {
2962 return nil, err
2963 }
2964 }
2965 args["before"] = arg1
2966 var arg2 *int
2967 if tmp, ok := rawArgs["first"]; ok {
2968 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2969 if err != nil {
2970 return nil, err
2971 }
2972 }
2973 args["first"] = arg2
2974 var arg3 *int
2975 if tmp, ok := rawArgs["last"]; ok {
2976 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2977 if err != nil {
2978 return nil, err
2979 }
2980 }
2981 args["last"] = arg3
2982 return args, nil
2983}
2984
2985func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2986 var err error
2987 args := map[string]interface{}{}
2988 var arg0 string
2989 if tmp, ok := rawArgs["prefix"]; ok {
2990 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2991 if err != nil {
2992 return nil, err
2993 }
2994 }
2995 args["prefix"] = arg0
2996 return args, nil
2997}
2998
2999func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3000 var err error
3001 args := map[string]interface{}{}
3002 var arg0 string
3003 if tmp, ok := rawArgs["prefix"]; ok {
3004 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3005 if err != nil {
3006 return nil, err
3007 }
3008 }
3009 args["prefix"] = arg0
3010 return args, nil
3011}
3012
3013func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3014 var err error
3015 args := map[string]interface{}{}
3016 var arg0 *string
3017 if tmp, ok := rawArgs["after"]; ok {
3018 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3019 if err != nil {
3020 return nil, err
3021 }
3022 }
3023 args["after"] = arg0
3024 var arg1 *string
3025 if tmp, ok := rawArgs["before"]; ok {
3026 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3027 if err != nil {
3028 return nil, err
3029 }
3030 }
3031 args["before"] = arg1
3032 var arg2 *int
3033 if tmp, ok := rawArgs["first"]; ok {
3034 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3035 if err != nil {
3036 return nil, err
3037 }
3038 }
3039 args["first"] = arg2
3040 var arg3 *int
3041 if tmp, ok := rawArgs["last"]; ok {
3042 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3043 if err != nil {
3044 return nil, err
3045 }
3046 }
3047 args["last"] = arg3
3048 return args, nil
3049}
3050
3051func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3052 var err error
3053 args := map[string]interface{}{}
3054 var arg0 bool
3055 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3056 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3057 if err != nil {
3058 return nil, err
3059 }
3060 }
3061 args["includeDeprecated"] = arg0
3062 return args, nil
3063}
3064
3065func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3066 var err error
3067 args := map[string]interface{}{}
3068 var arg0 bool
3069 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3070 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3071 if err != nil {
3072 return nil, err
3073 }
3074 }
3075 args["includeDeprecated"] = arg0
3076 return args, nil
3077}
3078
3079// endregion ***************************** args.gotpl *****************************
3080
3081// region ************************** directives.gotpl **************************
3082
3083// endregion ************************** directives.gotpl **************************
3084
3085// region **************************** field.gotpl *****************************
3086
3087func (ec *executionContext) _AddCommentAndCloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3088 defer func() {
3089 if r := recover(); r != nil {
3090 ec.Error(ctx, ec.Recover(ctx, r))
3091 ret = graphql.Null
3092 }
3093 }()
3094 fc := &graphql.FieldContext{
3095 Object: "AddCommentAndCloseBugPayload",
3096 Field: field,
3097 Args: nil,
3098 IsMethod: false,
3099 }
3100
3101 ctx = graphql.WithFieldContext(ctx, fc)
3102 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3103 ctx = rctx // use context from middleware stack in children
3104 return obj.ClientMutationID, nil
3105 })
3106 if err != nil {
3107 ec.Error(ctx, err)
3108 return graphql.Null
3109 }
3110 if resTmp == nil {
3111 return graphql.Null
3112 }
3113 res := resTmp.(*string)
3114 fc.Result = res
3115 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3116}
3117
3118func (ec *executionContext) _AddCommentAndCloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3119 defer func() {
3120 if r := recover(); r != nil {
3121 ec.Error(ctx, ec.Recover(ctx, r))
3122 ret = graphql.Null
3123 }
3124 }()
3125 fc := &graphql.FieldContext{
3126 Object: "AddCommentAndCloseBugPayload",
3127 Field: field,
3128 Args: nil,
3129 IsMethod: false,
3130 }
3131
3132 ctx = graphql.WithFieldContext(ctx, fc)
3133 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3134 ctx = rctx // use context from middleware stack in children
3135 return obj.Bug, nil
3136 })
3137 if err != nil {
3138 ec.Error(ctx, err)
3139 return graphql.Null
3140 }
3141 if resTmp == nil {
3142 if !graphql.HasFieldError(ctx, fc) {
3143 ec.Errorf(ctx, "must not be null")
3144 }
3145 return graphql.Null
3146 }
3147 res := resTmp.(models.BugWrapper)
3148 fc.Result = res
3149 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
3150}
3151
3152func (ec *executionContext) _AddCommentAndCloseBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3153 defer func() {
3154 if r := recover(); r != nil {
3155 ec.Error(ctx, ec.Recover(ctx, r))
3156 ret = graphql.Null
3157 }
3158 }()
3159 fc := &graphql.FieldContext{
3160 Object: "AddCommentAndCloseBugPayload",
3161 Field: field,
3162 Args: nil,
3163 IsMethod: false,
3164 }
3165
3166 ctx = graphql.WithFieldContext(ctx, fc)
3167 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3168 ctx = rctx // use context from middleware stack in children
3169 return obj.CommentOperation, nil
3170 })
3171 if err != nil {
3172 ec.Error(ctx, err)
3173 return graphql.Null
3174 }
3175 if resTmp == nil {
3176 if !graphql.HasFieldError(ctx, fc) {
3177 ec.Errorf(ctx, "must not be null")
3178 }
3179 return graphql.Null
3180 }
3181 res := resTmp.(*bug.AddCommentOperation)
3182 fc.Result = res
3183 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3184}
3185
3186func (ec *executionContext) _AddCommentAndCloseBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3187 defer func() {
3188 if r := recover(); r != nil {
3189 ec.Error(ctx, ec.Recover(ctx, r))
3190 ret = graphql.Null
3191 }
3192 }()
3193 fc := &graphql.FieldContext{
3194 Object: "AddCommentAndCloseBugPayload",
3195 Field: field,
3196 Args: nil,
3197 IsMethod: false,
3198 }
3199
3200 ctx = graphql.WithFieldContext(ctx, fc)
3201 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3202 ctx = rctx // use context from middleware stack in children
3203 return obj.StatusOperation, nil
3204 })
3205 if err != nil {
3206 ec.Error(ctx, err)
3207 return graphql.Null
3208 }
3209 if resTmp == nil {
3210 if !graphql.HasFieldError(ctx, fc) {
3211 ec.Errorf(ctx, "must not be null")
3212 }
3213 return graphql.Null
3214 }
3215 res := resTmp.(*bug.SetStatusOperation)
3216 fc.Result = res
3217 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
3218}
3219
3220func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3221 defer func() {
3222 if r := recover(); r != nil {
3223 ec.Error(ctx, ec.Recover(ctx, r))
3224 ret = graphql.Null
3225 }
3226 }()
3227 fc := &graphql.FieldContext{
3228 Object: "AddCommentOperation",
3229 Field: field,
3230 Args: nil,
3231 IsMethod: true,
3232 }
3233
3234 ctx = graphql.WithFieldContext(ctx, fc)
3235 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3236 ctx = rctx // use context from middleware stack in children
3237 return ec.resolvers.AddCommentOperation().ID(rctx, obj)
3238 })
3239 if err != nil {
3240 ec.Error(ctx, err)
3241 return graphql.Null
3242 }
3243 if resTmp == nil {
3244 if !graphql.HasFieldError(ctx, fc) {
3245 ec.Errorf(ctx, "must not be null")
3246 }
3247 return graphql.Null
3248 }
3249 res := resTmp.(string)
3250 fc.Result = res
3251 return ec.marshalNString2string(ctx, field.Selections, res)
3252}
3253
3254func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3255 defer func() {
3256 if r := recover(); r != nil {
3257 ec.Error(ctx, ec.Recover(ctx, r))
3258 ret = graphql.Null
3259 }
3260 }()
3261 fc := &graphql.FieldContext{
3262 Object: "AddCommentOperation",
3263 Field: field,
3264 Args: nil,
3265 IsMethod: true,
3266 }
3267
3268 ctx = graphql.WithFieldContext(ctx, fc)
3269 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3270 ctx = rctx // use context from middleware stack in children
3271 return ec.resolvers.AddCommentOperation().Author(rctx, obj)
3272 })
3273 if err != nil {
3274 ec.Error(ctx, err)
3275 return graphql.Null
3276 }
3277 if resTmp == nil {
3278 if !graphql.HasFieldError(ctx, fc) {
3279 ec.Errorf(ctx, "must not be null")
3280 }
3281 return graphql.Null
3282 }
3283 res := resTmp.(models.IdentityWrapper)
3284 fc.Result = res
3285 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3286}
3287
3288func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3289 defer func() {
3290 if r := recover(); r != nil {
3291 ec.Error(ctx, ec.Recover(ctx, r))
3292 ret = graphql.Null
3293 }
3294 }()
3295 fc := &graphql.FieldContext{
3296 Object: "AddCommentOperation",
3297 Field: field,
3298 Args: nil,
3299 IsMethod: true,
3300 }
3301
3302 ctx = graphql.WithFieldContext(ctx, fc)
3303 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3304 ctx = rctx // use context from middleware stack in children
3305 return ec.resolvers.AddCommentOperation().Date(rctx, obj)
3306 })
3307 if err != nil {
3308 ec.Error(ctx, err)
3309 return graphql.Null
3310 }
3311 if resTmp == nil {
3312 if !graphql.HasFieldError(ctx, fc) {
3313 ec.Errorf(ctx, "must not be null")
3314 }
3315 return graphql.Null
3316 }
3317 res := resTmp.(*time.Time)
3318 fc.Result = res
3319 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3320}
3321
3322func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3323 defer func() {
3324 if r := recover(); r != nil {
3325 ec.Error(ctx, ec.Recover(ctx, r))
3326 ret = graphql.Null
3327 }
3328 }()
3329 fc := &graphql.FieldContext{
3330 Object: "AddCommentOperation",
3331 Field: field,
3332 Args: nil,
3333 IsMethod: false,
3334 }
3335
3336 ctx = graphql.WithFieldContext(ctx, fc)
3337 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3338 ctx = rctx // use context from middleware stack in children
3339 return obj.Message, nil
3340 })
3341 if err != nil {
3342 ec.Error(ctx, err)
3343 return graphql.Null
3344 }
3345 if resTmp == nil {
3346 if !graphql.HasFieldError(ctx, fc) {
3347 ec.Errorf(ctx, "must not be null")
3348 }
3349 return graphql.Null
3350 }
3351 res := resTmp.(string)
3352 fc.Result = res
3353 return ec.marshalNString2string(ctx, field.Selections, res)
3354}
3355
3356func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3357 defer func() {
3358 if r := recover(); r != nil {
3359 ec.Error(ctx, ec.Recover(ctx, r))
3360 ret = graphql.Null
3361 }
3362 }()
3363 fc := &graphql.FieldContext{
3364 Object: "AddCommentOperation",
3365 Field: field,
3366 Args: nil,
3367 IsMethod: false,
3368 }
3369
3370 ctx = graphql.WithFieldContext(ctx, fc)
3371 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3372 ctx = rctx // use context from middleware stack in children
3373 return obj.Files, nil
3374 })
3375 if err != nil {
3376 ec.Error(ctx, err)
3377 return graphql.Null
3378 }
3379 if resTmp == nil {
3380 if !graphql.HasFieldError(ctx, fc) {
3381 ec.Errorf(ctx, "must not be null")
3382 }
3383 return graphql.Null
3384 }
3385 res := resTmp.([]repository.Hash)
3386 fc.Result = res
3387 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
3388}
3389
3390func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3391 defer func() {
3392 if r := recover(); r != nil {
3393 ec.Error(ctx, ec.Recover(ctx, r))
3394 ret = graphql.Null
3395 }
3396 }()
3397 fc := &graphql.FieldContext{
3398 Object: "AddCommentPayload",
3399 Field: field,
3400 Args: nil,
3401 IsMethod: false,
3402 }
3403
3404 ctx = graphql.WithFieldContext(ctx, fc)
3405 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3406 ctx = rctx // use context from middleware stack in children
3407 return obj.ClientMutationID, nil
3408 })
3409 if err != nil {
3410 ec.Error(ctx, err)
3411 return graphql.Null
3412 }
3413 if resTmp == nil {
3414 return graphql.Null
3415 }
3416 res := resTmp.(*string)
3417 fc.Result = res
3418 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3419}
3420
3421func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3422 defer func() {
3423 if r := recover(); r != nil {
3424 ec.Error(ctx, ec.Recover(ctx, r))
3425 ret = graphql.Null
3426 }
3427 }()
3428 fc := &graphql.FieldContext{
3429 Object: "AddCommentPayload",
3430 Field: field,
3431 Args: nil,
3432 IsMethod: false,
3433 }
3434
3435 ctx = graphql.WithFieldContext(ctx, fc)
3436 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3437 ctx = rctx // use context from middleware stack in children
3438 return obj.Bug, nil
3439 })
3440 if err != nil {
3441 ec.Error(ctx, err)
3442 return graphql.Null
3443 }
3444 if resTmp == nil {
3445 if !graphql.HasFieldError(ctx, fc) {
3446 ec.Errorf(ctx, "must not be null")
3447 }
3448 return graphql.Null
3449 }
3450 res := resTmp.(models.BugWrapper)
3451 fc.Result = res
3452 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
3453}
3454
3455func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3456 defer func() {
3457 if r := recover(); r != nil {
3458 ec.Error(ctx, ec.Recover(ctx, r))
3459 ret = graphql.Null
3460 }
3461 }()
3462 fc := &graphql.FieldContext{
3463 Object: "AddCommentPayload",
3464 Field: field,
3465 Args: nil,
3466 IsMethod: false,
3467 }
3468
3469 ctx = graphql.WithFieldContext(ctx, fc)
3470 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3471 ctx = rctx // use context from middleware stack in children
3472 return obj.Operation, nil
3473 })
3474 if err != nil {
3475 ec.Error(ctx, err)
3476 return graphql.Null
3477 }
3478 if resTmp == nil {
3479 if !graphql.HasFieldError(ctx, fc) {
3480 ec.Errorf(ctx, "must not be null")
3481 }
3482 return graphql.Null
3483 }
3484 res := resTmp.(*bug.AddCommentOperation)
3485 fc.Result = res
3486 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3487}
3488
3489func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3490 defer func() {
3491 if r := recover(); r != nil {
3492 ec.Error(ctx, ec.Recover(ctx, r))
3493 ret = graphql.Null
3494 }
3495 }()
3496 fc := &graphql.FieldContext{
3497 Object: "AddCommentTimelineItem",
3498 Field: field,
3499 Args: nil,
3500 IsMethod: true,
3501 }
3502
3503 ctx = graphql.WithFieldContext(ctx, fc)
3504 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3505 ctx = rctx // use context from middleware stack in children
3506 return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
3507 })
3508 if err != nil {
3509 ec.Error(ctx, err)
3510 return graphql.Null
3511 }
3512 if resTmp == nil {
3513 if !graphql.HasFieldError(ctx, fc) {
3514 ec.Errorf(ctx, "must not be null")
3515 }
3516 return graphql.Null
3517 }
3518 res := resTmp.(string)
3519 fc.Result = res
3520 return ec.marshalNString2string(ctx, field.Selections, res)
3521}
3522
3523func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3524 defer func() {
3525 if r := recover(); r != nil {
3526 ec.Error(ctx, ec.Recover(ctx, r))
3527 ret = graphql.Null
3528 }
3529 }()
3530 fc := &graphql.FieldContext{
3531 Object: "AddCommentTimelineItem",
3532 Field: field,
3533 Args: nil,
3534 IsMethod: true,
3535 }
3536
3537 ctx = graphql.WithFieldContext(ctx, fc)
3538 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3539 ctx = rctx // use context from middleware stack in children
3540 return ec.resolvers.AddCommentTimelineItem().Author(rctx, obj)
3541 })
3542 if err != nil {
3543 ec.Error(ctx, err)
3544 return graphql.Null
3545 }
3546 if resTmp == nil {
3547 if !graphql.HasFieldError(ctx, fc) {
3548 ec.Errorf(ctx, "must not be null")
3549 }
3550 return graphql.Null
3551 }
3552 res := resTmp.(models.IdentityWrapper)
3553 fc.Result = res
3554 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3555}
3556
3557func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3558 defer func() {
3559 if r := recover(); r != nil {
3560 ec.Error(ctx, ec.Recover(ctx, r))
3561 ret = graphql.Null
3562 }
3563 }()
3564 fc := &graphql.FieldContext{
3565 Object: "AddCommentTimelineItem",
3566 Field: field,
3567 Args: nil,
3568 IsMethod: false,
3569 }
3570
3571 ctx = graphql.WithFieldContext(ctx, fc)
3572 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3573 ctx = rctx // use context from middleware stack in children
3574 return obj.Message, nil
3575 })
3576 if err != nil {
3577 ec.Error(ctx, err)
3578 return graphql.Null
3579 }
3580 if resTmp == nil {
3581 if !graphql.HasFieldError(ctx, fc) {
3582 ec.Errorf(ctx, "must not be null")
3583 }
3584 return graphql.Null
3585 }
3586 res := resTmp.(string)
3587 fc.Result = res
3588 return ec.marshalNString2string(ctx, field.Selections, res)
3589}
3590
3591func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3592 defer func() {
3593 if r := recover(); r != nil {
3594 ec.Error(ctx, ec.Recover(ctx, r))
3595 ret = graphql.Null
3596 }
3597 }()
3598 fc := &graphql.FieldContext{
3599 Object: "AddCommentTimelineItem",
3600 Field: field,
3601 Args: nil,
3602 IsMethod: true,
3603 }
3604
3605 ctx = graphql.WithFieldContext(ctx, fc)
3606 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3607 ctx = rctx // use context from middleware stack in children
3608 return obj.MessageIsEmpty(), nil
3609 })
3610 if err != nil {
3611 ec.Error(ctx, err)
3612 return graphql.Null
3613 }
3614 if resTmp == nil {
3615 if !graphql.HasFieldError(ctx, fc) {
3616 ec.Errorf(ctx, "must not be null")
3617 }
3618 return graphql.Null
3619 }
3620 res := resTmp.(bool)
3621 fc.Result = res
3622 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3623}
3624
3625func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3626 defer func() {
3627 if r := recover(); r != nil {
3628 ec.Error(ctx, ec.Recover(ctx, r))
3629 ret = graphql.Null
3630 }
3631 }()
3632 fc := &graphql.FieldContext{
3633 Object: "AddCommentTimelineItem",
3634 Field: field,
3635 Args: nil,
3636 IsMethod: false,
3637 }
3638
3639 ctx = graphql.WithFieldContext(ctx, fc)
3640 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3641 ctx = rctx // use context from middleware stack in children
3642 return obj.Files, nil
3643 })
3644 if err != nil {
3645 ec.Error(ctx, err)
3646 return graphql.Null
3647 }
3648 if resTmp == nil {
3649 if !graphql.HasFieldError(ctx, fc) {
3650 ec.Errorf(ctx, "must not be null")
3651 }
3652 return graphql.Null
3653 }
3654 res := resTmp.([]repository.Hash)
3655 fc.Result = res
3656 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
3657}
3658
3659func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3660 defer func() {
3661 if r := recover(); r != nil {
3662 ec.Error(ctx, ec.Recover(ctx, r))
3663 ret = graphql.Null
3664 }
3665 }()
3666 fc := &graphql.FieldContext{
3667 Object: "AddCommentTimelineItem",
3668 Field: field,
3669 Args: nil,
3670 IsMethod: true,
3671 }
3672
3673 ctx = graphql.WithFieldContext(ctx, fc)
3674 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3675 ctx = rctx // use context from middleware stack in children
3676 return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
3677 })
3678 if err != nil {
3679 ec.Error(ctx, err)
3680 return graphql.Null
3681 }
3682 if resTmp == nil {
3683 if !graphql.HasFieldError(ctx, fc) {
3684 ec.Errorf(ctx, "must not be null")
3685 }
3686 return graphql.Null
3687 }
3688 res := resTmp.(*time.Time)
3689 fc.Result = res
3690 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3691}
3692
3693func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3694 defer func() {
3695 if r := recover(); r != nil {
3696 ec.Error(ctx, ec.Recover(ctx, r))
3697 ret = graphql.Null
3698 }
3699 }()
3700 fc := &graphql.FieldContext{
3701 Object: "AddCommentTimelineItem",
3702 Field: field,
3703 Args: nil,
3704 IsMethod: true,
3705 }
3706
3707 ctx = graphql.WithFieldContext(ctx, fc)
3708 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3709 ctx = rctx // use context from middleware stack in children
3710 return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
3711 })
3712 if err != nil {
3713 ec.Error(ctx, err)
3714 return graphql.Null
3715 }
3716 if resTmp == nil {
3717 if !graphql.HasFieldError(ctx, fc) {
3718 ec.Errorf(ctx, "must not be null")
3719 }
3720 return graphql.Null
3721 }
3722 res := resTmp.(*time.Time)
3723 fc.Result = res
3724 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3725}
3726
3727func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3728 defer func() {
3729 if r := recover(); r != nil {
3730 ec.Error(ctx, ec.Recover(ctx, r))
3731 ret = graphql.Null
3732 }
3733 }()
3734 fc := &graphql.FieldContext{
3735 Object: "AddCommentTimelineItem",
3736 Field: field,
3737 Args: nil,
3738 IsMethod: true,
3739 }
3740
3741 ctx = graphql.WithFieldContext(ctx, fc)
3742 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3743 ctx = rctx // use context from middleware stack in children
3744 return obj.Edited(), nil
3745 })
3746 if err != nil {
3747 ec.Error(ctx, err)
3748 return graphql.Null
3749 }
3750 if resTmp == nil {
3751 if !graphql.HasFieldError(ctx, fc) {
3752 ec.Errorf(ctx, "must not be null")
3753 }
3754 return graphql.Null
3755 }
3756 res := resTmp.(bool)
3757 fc.Result = res
3758 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3759}
3760
3761func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3762 defer func() {
3763 if r := recover(); r != nil {
3764 ec.Error(ctx, ec.Recover(ctx, r))
3765 ret = graphql.Null
3766 }
3767 }()
3768 fc := &graphql.FieldContext{
3769 Object: "AddCommentTimelineItem",
3770 Field: field,
3771 Args: nil,
3772 IsMethod: false,
3773 }
3774
3775 ctx = graphql.WithFieldContext(ctx, fc)
3776 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3777 ctx = rctx // use context from middleware stack in children
3778 return obj.History, nil
3779 })
3780 if err != nil {
3781 ec.Error(ctx, err)
3782 return graphql.Null
3783 }
3784 if resTmp == nil {
3785 if !graphql.HasFieldError(ctx, fc) {
3786 ec.Errorf(ctx, "must not be null")
3787 }
3788 return graphql.Null
3789 }
3790 res := resTmp.([]bug.CommentHistoryStep)
3791 fc.Result = res
3792 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
3793}
3794
3795func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3796 defer func() {
3797 if r := recover(); r != nil {
3798 ec.Error(ctx, ec.Recover(ctx, r))
3799 ret = graphql.Null
3800 }
3801 }()
3802 fc := &graphql.FieldContext{
3803 Object: "Bug",
3804 Field: field,
3805 Args: nil,
3806 IsMethod: true,
3807 }
3808
3809 ctx = graphql.WithFieldContext(ctx, fc)
3810 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3811 ctx = rctx // use context from middleware stack in children
3812 return ec.resolvers.Bug().ID(rctx, obj)
3813 })
3814 if err != nil {
3815 ec.Error(ctx, err)
3816 return graphql.Null
3817 }
3818 if resTmp == nil {
3819 if !graphql.HasFieldError(ctx, fc) {
3820 ec.Errorf(ctx, "must not be null")
3821 }
3822 return graphql.Null
3823 }
3824 res := resTmp.(string)
3825 fc.Result = res
3826 return ec.marshalNString2string(ctx, field.Selections, res)
3827}
3828
3829func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3830 defer func() {
3831 if r := recover(); r != nil {
3832 ec.Error(ctx, ec.Recover(ctx, r))
3833 ret = graphql.Null
3834 }
3835 }()
3836 fc := &graphql.FieldContext{
3837 Object: "Bug",
3838 Field: field,
3839 Args: nil,
3840 IsMethod: true,
3841 }
3842
3843 ctx = graphql.WithFieldContext(ctx, fc)
3844 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3845 ctx = rctx // use context from middleware stack in children
3846 return ec.resolvers.Bug().HumanID(rctx, obj)
3847 })
3848 if err != nil {
3849 ec.Error(ctx, err)
3850 return graphql.Null
3851 }
3852 if resTmp == nil {
3853 if !graphql.HasFieldError(ctx, fc) {
3854 ec.Errorf(ctx, "must not be null")
3855 }
3856 return graphql.Null
3857 }
3858 res := resTmp.(string)
3859 fc.Result = res
3860 return ec.marshalNString2string(ctx, field.Selections, res)
3861}
3862
3863func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3864 defer func() {
3865 if r := recover(); r != nil {
3866 ec.Error(ctx, ec.Recover(ctx, r))
3867 ret = graphql.Null
3868 }
3869 }()
3870 fc := &graphql.FieldContext{
3871 Object: "Bug",
3872 Field: field,
3873 Args: nil,
3874 IsMethod: true,
3875 }
3876
3877 ctx = graphql.WithFieldContext(ctx, fc)
3878 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3879 ctx = rctx // use context from middleware stack in children
3880 return ec.resolvers.Bug().Status(rctx, obj)
3881 })
3882 if err != nil {
3883 ec.Error(ctx, err)
3884 return graphql.Null
3885 }
3886 if resTmp == nil {
3887 if !graphql.HasFieldError(ctx, fc) {
3888 ec.Errorf(ctx, "must not be null")
3889 }
3890 return graphql.Null
3891 }
3892 res := resTmp.(models.Status)
3893 fc.Result = res
3894 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
3895}
3896
3897func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3898 defer func() {
3899 if r := recover(); r != nil {
3900 ec.Error(ctx, ec.Recover(ctx, r))
3901 ret = graphql.Null
3902 }
3903 }()
3904 fc := &graphql.FieldContext{
3905 Object: "Bug",
3906 Field: field,
3907 Args: nil,
3908 IsMethod: true,
3909 }
3910
3911 ctx = graphql.WithFieldContext(ctx, fc)
3912 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3913 ctx = rctx // use context from middleware stack in children
3914 return obj.Title(), nil
3915 })
3916 if err != nil {
3917 ec.Error(ctx, err)
3918 return graphql.Null
3919 }
3920 if resTmp == nil {
3921 if !graphql.HasFieldError(ctx, fc) {
3922 ec.Errorf(ctx, "must not be null")
3923 }
3924 return graphql.Null
3925 }
3926 res := resTmp.(string)
3927 fc.Result = res
3928 return ec.marshalNString2string(ctx, field.Selections, res)
3929}
3930
3931func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3932 defer func() {
3933 if r := recover(); r != nil {
3934 ec.Error(ctx, ec.Recover(ctx, r))
3935 ret = graphql.Null
3936 }
3937 }()
3938 fc := &graphql.FieldContext{
3939 Object: "Bug",
3940 Field: field,
3941 Args: nil,
3942 IsMethod: true,
3943 }
3944
3945 ctx = graphql.WithFieldContext(ctx, fc)
3946 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3947 ctx = rctx // use context from middleware stack in children
3948 return obj.Labels(), nil
3949 })
3950 if err != nil {
3951 ec.Error(ctx, err)
3952 return graphql.Null
3953 }
3954 if resTmp == nil {
3955 if !graphql.HasFieldError(ctx, fc) {
3956 ec.Errorf(ctx, "must not be null")
3957 }
3958 return graphql.Null
3959 }
3960 res := resTmp.([]bug.Label)
3961 fc.Result = res
3962 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
3963}
3964
3965func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
3966 defer func() {
3967 if r := recover(); r != nil {
3968 ec.Error(ctx, ec.Recover(ctx, r))
3969 ret = graphql.Null
3970 }
3971 }()
3972 fc := &graphql.FieldContext{
3973 Object: "Bug",
3974 Field: field,
3975 Args: nil,
3976 IsMethod: true,
3977 }
3978
3979 ctx = graphql.WithFieldContext(ctx, fc)
3980 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3981 ctx = rctx // use context from middleware stack in children
3982 return obj.Author()
3983 })
3984 if err != nil {
3985 ec.Error(ctx, err)
3986 return graphql.Null
3987 }
3988 if resTmp == nil {
3989 if !graphql.HasFieldError(ctx, fc) {
3990 ec.Errorf(ctx, "must not be null")
3991 }
3992 return graphql.Null
3993 }
3994 res := resTmp.(models.IdentityWrapper)
3995 fc.Result = res
3996 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3997}
3998
3999func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4000 defer func() {
4001 if r := recover(); r != nil {
4002 ec.Error(ctx, ec.Recover(ctx, r))
4003 ret = graphql.Null
4004 }
4005 }()
4006 fc := &graphql.FieldContext{
4007 Object: "Bug",
4008 Field: field,
4009 Args: nil,
4010 IsMethod: true,
4011 }
4012
4013 ctx = graphql.WithFieldContext(ctx, fc)
4014 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4015 ctx = rctx // use context from middleware stack in children
4016 return obj.CreatedAt(), nil
4017 })
4018 if err != nil {
4019 ec.Error(ctx, err)
4020 return graphql.Null
4021 }
4022 if resTmp == nil {
4023 if !graphql.HasFieldError(ctx, fc) {
4024 ec.Errorf(ctx, "must not be null")
4025 }
4026 return graphql.Null
4027 }
4028 res := resTmp.(time.Time)
4029 fc.Result = res
4030 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
4031}
4032
4033func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4034 defer func() {
4035 if r := recover(); r != nil {
4036 ec.Error(ctx, ec.Recover(ctx, r))
4037 ret = graphql.Null
4038 }
4039 }()
4040 fc := &graphql.FieldContext{
4041 Object: "Bug",
4042 Field: field,
4043 Args: nil,
4044 IsMethod: true,
4045 }
4046
4047 ctx = graphql.WithFieldContext(ctx, fc)
4048 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4049 ctx = rctx // use context from middleware stack in children
4050 return obj.LastEdit(), nil
4051 })
4052 if err != nil {
4053 ec.Error(ctx, err)
4054 return graphql.Null
4055 }
4056 if resTmp == nil {
4057 if !graphql.HasFieldError(ctx, fc) {
4058 ec.Errorf(ctx, "must not be null")
4059 }
4060 return graphql.Null
4061 }
4062 res := resTmp.(time.Time)
4063 fc.Result = res
4064 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
4065}
4066
4067func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4068 defer func() {
4069 if r := recover(); r != nil {
4070 ec.Error(ctx, ec.Recover(ctx, r))
4071 ret = graphql.Null
4072 }
4073 }()
4074 fc := &graphql.FieldContext{
4075 Object: "Bug",
4076 Field: field,
4077 Args: nil,
4078 IsMethod: true,
4079 }
4080
4081 ctx = graphql.WithFieldContext(ctx, fc)
4082 rawArgs := field.ArgumentMap(ec.Variables)
4083 args, err := ec.field_Bug_actors_args(ctx, rawArgs)
4084 if err != nil {
4085 ec.Error(ctx, err)
4086 return graphql.Null
4087 }
4088 fc.Args = args
4089 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4090 ctx = rctx // use context from middleware stack in children
4091 return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4092 })
4093 if err != nil {
4094 ec.Error(ctx, err)
4095 return graphql.Null
4096 }
4097 if resTmp == nil {
4098 if !graphql.HasFieldError(ctx, fc) {
4099 ec.Errorf(ctx, "must not be null")
4100 }
4101 return graphql.Null
4102 }
4103 res := resTmp.(*models.IdentityConnection)
4104 fc.Result = res
4105 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4106}
4107
4108func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4109 defer func() {
4110 if r := recover(); r != nil {
4111 ec.Error(ctx, ec.Recover(ctx, r))
4112 ret = graphql.Null
4113 }
4114 }()
4115 fc := &graphql.FieldContext{
4116 Object: "Bug",
4117 Field: field,
4118 Args: nil,
4119 IsMethod: true,
4120 }
4121
4122 ctx = graphql.WithFieldContext(ctx, fc)
4123 rawArgs := field.ArgumentMap(ec.Variables)
4124 args, err := ec.field_Bug_participants_args(ctx, rawArgs)
4125 if err != nil {
4126 ec.Error(ctx, err)
4127 return graphql.Null
4128 }
4129 fc.Args = args
4130 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4131 ctx = rctx // use context from middleware stack in children
4132 return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4133 })
4134 if err != nil {
4135 ec.Error(ctx, err)
4136 return graphql.Null
4137 }
4138 if resTmp == nil {
4139 if !graphql.HasFieldError(ctx, fc) {
4140 ec.Errorf(ctx, "must not be null")
4141 }
4142 return graphql.Null
4143 }
4144 res := resTmp.(*models.IdentityConnection)
4145 fc.Result = res
4146 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4147}
4148
4149func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4150 defer func() {
4151 if r := recover(); r != nil {
4152 ec.Error(ctx, ec.Recover(ctx, r))
4153 ret = graphql.Null
4154 }
4155 }()
4156 fc := &graphql.FieldContext{
4157 Object: "Bug",
4158 Field: field,
4159 Args: nil,
4160 IsMethod: true,
4161 }
4162
4163 ctx = graphql.WithFieldContext(ctx, fc)
4164 rawArgs := field.ArgumentMap(ec.Variables)
4165 args, err := ec.field_Bug_comments_args(ctx, rawArgs)
4166 if err != nil {
4167 ec.Error(ctx, err)
4168 return graphql.Null
4169 }
4170 fc.Args = args
4171 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4172 ctx = rctx // use context from middleware stack in children
4173 return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4174 })
4175 if err != nil {
4176 ec.Error(ctx, err)
4177 return graphql.Null
4178 }
4179 if resTmp == nil {
4180 if !graphql.HasFieldError(ctx, fc) {
4181 ec.Errorf(ctx, "must not be null")
4182 }
4183 return graphql.Null
4184 }
4185 res := resTmp.(*models.CommentConnection)
4186 fc.Result = res
4187 return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
4188}
4189
4190func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4191 defer func() {
4192 if r := recover(); r != nil {
4193 ec.Error(ctx, ec.Recover(ctx, r))
4194 ret = graphql.Null
4195 }
4196 }()
4197 fc := &graphql.FieldContext{
4198 Object: "Bug",
4199 Field: field,
4200 Args: nil,
4201 IsMethod: true,
4202 }
4203
4204 ctx = graphql.WithFieldContext(ctx, fc)
4205 rawArgs := field.ArgumentMap(ec.Variables)
4206 args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
4207 if err != nil {
4208 ec.Error(ctx, err)
4209 return graphql.Null
4210 }
4211 fc.Args = args
4212 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4213 ctx = rctx // use context from middleware stack in children
4214 return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4215 })
4216 if err != nil {
4217 ec.Error(ctx, err)
4218 return graphql.Null
4219 }
4220 if resTmp == nil {
4221 if !graphql.HasFieldError(ctx, fc) {
4222 ec.Errorf(ctx, "must not be null")
4223 }
4224 return graphql.Null
4225 }
4226 res := resTmp.(*models.TimelineItemConnection)
4227 fc.Result = res
4228 return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
4229}
4230
4231func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4232 defer func() {
4233 if r := recover(); r != nil {
4234 ec.Error(ctx, ec.Recover(ctx, r))
4235 ret = graphql.Null
4236 }
4237 }()
4238 fc := &graphql.FieldContext{
4239 Object: "Bug",
4240 Field: field,
4241 Args: nil,
4242 IsMethod: true,
4243 }
4244
4245 ctx = graphql.WithFieldContext(ctx, fc)
4246 rawArgs := field.ArgumentMap(ec.Variables)
4247 args, err := ec.field_Bug_operations_args(ctx, rawArgs)
4248 if err != nil {
4249 ec.Error(ctx, err)
4250 return graphql.Null
4251 }
4252 fc.Args = args
4253 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4254 ctx = rctx // use context from middleware stack in children
4255 return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4256 })
4257 if err != nil {
4258 ec.Error(ctx, err)
4259 return graphql.Null
4260 }
4261 if resTmp == nil {
4262 if !graphql.HasFieldError(ctx, fc) {
4263 ec.Errorf(ctx, "must not be null")
4264 }
4265 return graphql.Null
4266 }
4267 res := resTmp.(*models.OperationConnection)
4268 fc.Result = res
4269 return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
4270}
4271
4272func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4273 defer func() {
4274 if r := recover(); r != nil {
4275 ec.Error(ctx, ec.Recover(ctx, r))
4276 ret = graphql.Null
4277 }
4278 }()
4279 fc := &graphql.FieldContext{
4280 Object: "BugConnection",
4281 Field: field,
4282 Args: nil,
4283 IsMethod: false,
4284 }
4285
4286 ctx = graphql.WithFieldContext(ctx, fc)
4287 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4288 ctx = rctx // use context from middleware stack in children
4289 return obj.Edges, nil
4290 })
4291 if err != nil {
4292 ec.Error(ctx, err)
4293 return graphql.Null
4294 }
4295 if resTmp == nil {
4296 if !graphql.HasFieldError(ctx, fc) {
4297 ec.Errorf(ctx, "must not be null")
4298 }
4299 return graphql.Null
4300 }
4301 res := resTmp.([]*models.BugEdge)
4302 fc.Result = res
4303 return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
4304}
4305
4306func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4307 defer func() {
4308 if r := recover(); r != nil {
4309 ec.Error(ctx, ec.Recover(ctx, r))
4310 ret = graphql.Null
4311 }
4312 }()
4313 fc := &graphql.FieldContext{
4314 Object: "BugConnection",
4315 Field: field,
4316 Args: nil,
4317 IsMethod: false,
4318 }
4319
4320 ctx = graphql.WithFieldContext(ctx, fc)
4321 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4322 ctx = rctx // use context from middleware stack in children
4323 return obj.Nodes, nil
4324 })
4325 if err != nil {
4326 ec.Error(ctx, err)
4327 return graphql.Null
4328 }
4329 if resTmp == nil {
4330 if !graphql.HasFieldError(ctx, fc) {
4331 ec.Errorf(ctx, "must not be null")
4332 }
4333 return graphql.Null
4334 }
4335 res := resTmp.([]models.BugWrapper)
4336 fc.Result = res
4337 return ec.marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx, field.Selections, res)
4338}
4339
4340func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4341 defer func() {
4342 if r := recover(); r != nil {
4343 ec.Error(ctx, ec.Recover(ctx, r))
4344 ret = graphql.Null
4345 }
4346 }()
4347 fc := &graphql.FieldContext{
4348 Object: "BugConnection",
4349 Field: field,
4350 Args: nil,
4351 IsMethod: false,
4352 }
4353
4354 ctx = graphql.WithFieldContext(ctx, fc)
4355 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4356 ctx = rctx // use context from middleware stack in children
4357 return obj.PageInfo, nil
4358 })
4359 if err != nil {
4360 ec.Error(ctx, err)
4361 return graphql.Null
4362 }
4363 if resTmp == nil {
4364 if !graphql.HasFieldError(ctx, fc) {
4365 ec.Errorf(ctx, "must not be null")
4366 }
4367 return graphql.Null
4368 }
4369 res := resTmp.(*models.PageInfo)
4370 fc.Result = res
4371 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
4372}
4373
4374func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4375 defer func() {
4376 if r := recover(); r != nil {
4377 ec.Error(ctx, ec.Recover(ctx, r))
4378 ret = graphql.Null
4379 }
4380 }()
4381 fc := &graphql.FieldContext{
4382 Object: "BugConnection",
4383 Field: field,
4384 Args: nil,
4385 IsMethod: false,
4386 }
4387
4388 ctx = graphql.WithFieldContext(ctx, fc)
4389 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4390 ctx = rctx // use context from middleware stack in children
4391 return obj.TotalCount, nil
4392 })
4393 if err != nil {
4394 ec.Error(ctx, err)
4395 return graphql.Null
4396 }
4397 if resTmp == nil {
4398 if !graphql.HasFieldError(ctx, fc) {
4399 ec.Errorf(ctx, "must not be null")
4400 }
4401 return graphql.Null
4402 }
4403 res := resTmp.(int)
4404 fc.Result = res
4405 return ec.marshalNInt2int(ctx, field.Selections, res)
4406}
4407
4408func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4409 defer func() {
4410 if r := recover(); r != nil {
4411 ec.Error(ctx, ec.Recover(ctx, r))
4412 ret = graphql.Null
4413 }
4414 }()
4415 fc := &graphql.FieldContext{
4416 Object: "BugEdge",
4417 Field: field,
4418 Args: nil,
4419 IsMethod: false,
4420 }
4421
4422 ctx = graphql.WithFieldContext(ctx, fc)
4423 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4424 ctx = rctx // use context from middleware stack in children
4425 return obj.Cursor, nil
4426 })
4427 if err != nil {
4428 ec.Error(ctx, err)
4429 return graphql.Null
4430 }
4431 if resTmp == nil {
4432 if !graphql.HasFieldError(ctx, fc) {
4433 ec.Errorf(ctx, "must not be null")
4434 }
4435 return graphql.Null
4436 }
4437 res := resTmp.(string)
4438 fc.Result = res
4439 return ec.marshalNString2string(ctx, field.Selections, res)
4440}
4441
4442func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4443 defer func() {
4444 if r := recover(); r != nil {
4445 ec.Error(ctx, ec.Recover(ctx, r))
4446 ret = graphql.Null
4447 }
4448 }()
4449 fc := &graphql.FieldContext{
4450 Object: "BugEdge",
4451 Field: field,
4452 Args: nil,
4453 IsMethod: false,
4454 }
4455
4456 ctx = graphql.WithFieldContext(ctx, fc)
4457 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4458 ctx = rctx // use context from middleware stack in children
4459 return obj.Node, nil
4460 })
4461 if err != nil {
4462 ec.Error(ctx, err)
4463 return graphql.Null
4464 }
4465 if resTmp == nil {
4466 if !graphql.HasFieldError(ctx, fc) {
4467 ec.Errorf(ctx, "must not be null")
4468 }
4469 return graphql.Null
4470 }
4471 res := resTmp.(models.BugWrapper)
4472 fc.Result = res
4473 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4474}
4475
4476func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4477 defer func() {
4478 if r := recover(); r != nil {
4479 ec.Error(ctx, ec.Recover(ctx, r))
4480 ret = graphql.Null
4481 }
4482 }()
4483 fc := &graphql.FieldContext{
4484 Object: "ChangeLabelPayload",
4485 Field: field,
4486 Args: nil,
4487 IsMethod: false,
4488 }
4489
4490 ctx = graphql.WithFieldContext(ctx, fc)
4491 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4492 ctx = rctx // use context from middleware stack in children
4493 return obj.ClientMutationID, nil
4494 })
4495 if err != nil {
4496 ec.Error(ctx, err)
4497 return graphql.Null
4498 }
4499 if resTmp == nil {
4500 return graphql.Null
4501 }
4502 res := resTmp.(*string)
4503 fc.Result = res
4504 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4505}
4506
4507func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4508 defer func() {
4509 if r := recover(); r != nil {
4510 ec.Error(ctx, ec.Recover(ctx, r))
4511 ret = graphql.Null
4512 }
4513 }()
4514 fc := &graphql.FieldContext{
4515 Object: "ChangeLabelPayload",
4516 Field: field,
4517 Args: nil,
4518 IsMethod: false,
4519 }
4520
4521 ctx = graphql.WithFieldContext(ctx, fc)
4522 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4523 ctx = rctx // use context from middleware stack in children
4524 return obj.Bug, nil
4525 })
4526 if err != nil {
4527 ec.Error(ctx, err)
4528 return graphql.Null
4529 }
4530 if resTmp == nil {
4531 if !graphql.HasFieldError(ctx, fc) {
4532 ec.Errorf(ctx, "must not be null")
4533 }
4534 return graphql.Null
4535 }
4536 res := resTmp.(models.BugWrapper)
4537 fc.Result = res
4538 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4539}
4540
4541func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4542 defer func() {
4543 if r := recover(); r != nil {
4544 ec.Error(ctx, ec.Recover(ctx, r))
4545 ret = graphql.Null
4546 }
4547 }()
4548 fc := &graphql.FieldContext{
4549 Object: "ChangeLabelPayload",
4550 Field: field,
4551 Args: nil,
4552 IsMethod: false,
4553 }
4554
4555 ctx = graphql.WithFieldContext(ctx, fc)
4556 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4557 ctx = rctx // use context from middleware stack in children
4558 return obj.Operation, nil
4559 })
4560 if err != nil {
4561 ec.Error(ctx, err)
4562 return graphql.Null
4563 }
4564 if resTmp == nil {
4565 if !graphql.HasFieldError(ctx, fc) {
4566 ec.Errorf(ctx, "must not be null")
4567 }
4568 return graphql.Null
4569 }
4570 res := resTmp.(*bug.LabelChangeOperation)
4571 fc.Result = res
4572 return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
4573}
4574
4575func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4576 defer func() {
4577 if r := recover(); r != nil {
4578 ec.Error(ctx, ec.Recover(ctx, r))
4579 ret = graphql.Null
4580 }
4581 }()
4582 fc := &graphql.FieldContext{
4583 Object: "ChangeLabelPayload",
4584 Field: field,
4585 Args: nil,
4586 IsMethod: false,
4587 }
4588
4589 ctx = graphql.WithFieldContext(ctx, fc)
4590 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4591 ctx = rctx // use context from middleware stack in children
4592 return obj.Results, nil
4593 })
4594 if err != nil {
4595 ec.Error(ctx, err)
4596 return graphql.Null
4597 }
4598 if resTmp == nil {
4599 if !graphql.HasFieldError(ctx, fc) {
4600 ec.Errorf(ctx, "must not be null")
4601 }
4602 return graphql.Null
4603 }
4604 res := resTmp.([]*bug.LabelChangeResult)
4605 fc.Result = res
4606 return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
4607}
4608
4609func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4610 defer func() {
4611 if r := recover(); r != nil {
4612 ec.Error(ctx, ec.Recover(ctx, r))
4613 ret = graphql.Null
4614 }
4615 }()
4616 fc := &graphql.FieldContext{
4617 Object: "CloseBugPayload",
4618 Field: field,
4619 Args: nil,
4620 IsMethod: false,
4621 }
4622
4623 ctx = graphql.WithFieldContext(ctx, fc)
4624 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4625 ctx = rctx // use context from middleware stack in children
4626 return obj.ClientMutationID, nil
4627 })
4628 if err != nil {
4629 ec.Error(ctx, err)
4630 return graphql.Null
4631 }
4632 if resTmp == nil {
4633 return graphql.Null
4634 }
4635 res := resTmp.(*string)
4636 fc.Result = res
4637 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4638}
4639
4640func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4641 defer func() {
4642 if r := recover(); r != nil {
4643 ec.Error(ctx, ec.Recover(ctx, r))
4644 ret = graphql.Null
4645 }
4646 }()
4647 fc := &graphql.FieldContext{
4648 Object: "CloseBugPayload",
4649 Field: field,
4650 Args: nil,
4651 IsMethod: false,
4652 }
4653
4654 ctx = graphql.WithFieldContext(ctx, fc)
4655 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4656 ctx = rctx // use context from middleware stack in children
4657 return obj.Bug, nil
4658 })
4659 if err != nil {
4660 ec.Error(ctx, err)
4661 return graphql.Null
4662 }
4663 if resTmp == nil {
4664 if !graphql.HasFieldError(ctx, fc) {
4665 ec.Errorf(ctx, "must not be null")
4666 }
4667 return graphql.Null
4668 }
4669 res := resTmp.(models.BugWrapper)
4670 fc.Result = res
4671 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4672}
4673
4674func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4675 defer func() {
4676 if r := recover(); r != nil {
4677 ec.Error(ctx, ec.Recover(ctx, r))
4678 ret = graphql.Null
4679 }
4680 }()
4681 fc := &graphql.FieldContext{
4682 Object: "CloseBugPayload",
4683 Field: field,
4684 Args: nil,
4685 IsMethod: false,
4686 }
4687
4688 ctx = graphql.WithFieldContext(ctx, fc)
4689 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4690 ctx = rctx // use context from middleware stack in children
4691 return obj.Operation, nil
4692 })
4693 if err != nil {
4694 ec.Error(ctx, err)
4695 return graphql.Null
4696 }
4697 if resTmp == nil {
4698 if !graphql.HasFieldError(ctx, fc) {
4699 ec.Errorf(ctx, "must not be null")
4700 }
4701 return graphql.Null
4702 }
4703 res := resTmp.(*bug.SetStatusOperation)
4704 fc.Result = res
4705 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
4706}
4707
4708func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4709 defer func() {
4710 if r := recover(); r != nil {
4711 ec.Error(ctx, ec.Recover(ctx, r))
4712 ret = graphql.Null
4713 }
4714 }()
4715 fc := &graphql.FieldContext{
4716 Object: "Color",
4717 Field: field,
4718 Args: nil,
4719 IsMethod: true,
4720 }
4721
4722 ctx = graphql.WithFieldContext(ctx, fc)
4723 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4724 ctx = rctx // use context from middleware stack in children
4725 return ec.resolvers.Color().R(rctx, obj)
4726 })
4727 if err != nil {
4728 ec.Error(ctx, err)
4729 return graphql.Null
4730 }
4731 if resTmp == nil {
4732 if !graphql.HasFieldError(ctx, fc) {
4733 ec.Errorf(ctx, "must not be null")
4734 }
4735 return graphql.Null
4736 }
4737 res := resTmp.(int)
4738 fc.Result = res
4739 return ec.marshalNInt2int(ctx, field.Selections, res)
4740}
4741
4742func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4743 defer func() {
4744 if r := recover(); r != nil {
4745 ec.Error(ctx, ec.Recover(ctx, r))
4746 ret = graphql.Null
4747 }
4748 }()
4749 fc := &graphql.FieldContext{
4750 Object: "Color",
4751 Field: field,
4752 Args: nil,
4753 IsMethod: true,
4754 }
4755
4756 ctx = graphql.WithFieldContext(ctx, fc)
4757 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4758 ctx = rctx // use context from middleware stack in children
4759 return ec.resolvers.Color().G(rctx, obj)
4760 })
4761 if err != nil {
4762 ec.Error(ctx, err)
4763 return graphql.Null
4764 }
4765 if resTmp == nil {
4766 if !graphql.HasFieldError(ctx, fc) {
4767 ec.Errorf(ctx, "must not be null")
4768 }
4769 return graphql.Null
4770 }
4771 res := resTmp.(int)
4772 fc.Result = res
4773 return ec.marshalNInt2int(ctx, field.Selections, res)
4774}
4775
4776func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4777 defer func() {
4778 if r := recover(); r != nil {
4779 ec.Error(ctx, ec.Recover(ctx, r))
4780 ret = graphql.Null
4781 }
4782 }()
4783 fc := &graphql.FieldContext{
4784 Object: "Color",
4785 Field: field,
4786 Args: nil,
4787 IsMethod: true,
4788 }
4789
4790 ctx = graphql.WithFieldContext(ctx, fc)
4791 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4792 ctx = rctx // use context from middleware stack in children
4793 return ec.resolvers.Color().B(rctx, obj)
4794 })
4795 if err != nil {
4796 ec.Error(ctx, err)
4797 return graphql.Null
4798 }
4799 if resTmp == nil {
4800 if !graphql.HasFieldError(ctx, fc) {
4801 ec.Errorf(ctx, "must not be null")
4802 }
4803 return graphql.Null
4804 }
4805 res := resTmp.(int)
4806 fc.Result = res
4807 return ec.marshalNInt2int(ctx, field.Selections, res)
4808}
4809
4810func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4811 defer func() {
4812 if r := recover(); r != nil {
4813 ec.Error(ctx, ec.Recover(ctx, r))
4814 ret = graphql.Null
4815 }
4816 }()
4817 fc := &graphql.FieldContext{
4818 Object: "Comment",
4819 Field: field,
4820 Args: nil,
4821 IsMethod: true,
4822 }
4823
4824 ctx = graphql.WithFieldContext(ctx, fc)
4825 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4826 ctx = rctx // use context from middleware stack in children
4827 return ec.resolvers.Comment().Author(rctx, obj)
4828 })
4829 if err != nil {
4830 ec.Error(ctx, err)
4831 return graphql.Null
4832 }
4833 if resTmp == nil {
4834 if !graphql.HasFieldError(ctx, fc) {
4835 ec.Errorf(ctx, "must not be null")
4836 }
4837 return graphql.Null
4838 }
4839 res := resTmp.(models.IdentityWrapper)
4840 fc.Result = res
4841 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
4842}
4843
4844func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4845 defer func() {
4846 if r := recover(); r != nil {
4847 ec.Error(ctx, ec.Recover(ctx, r))
4848 ret = graphql.Null
4849 }
4850 }()
4851 fc := &graphql.FieldContext{
4852 Object: "Comment",
4853 Field: field,
4854 Args: nil,
4855 IsMethod: false,
4856 }
4857
4858 ctx = graphql.WithFieldContext(ctx, fc)
4859 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4860 ctx = rctx // use context from middleware stack in children
4861 return obj.Message, nil
4862 })
4863 if err != nil {
4864 ec.Error(ctx, err)
4865 return graphql.Null
4866 }
4867 if resTmp == nil {
4868 if !graphql.HasFieldError(ctx, fc) {
4869 ec.Errorf(ctx, "must not be null")
4870 }
4871 return graphql.Null
4872 }
4873 res := resTmp.(string)
4874 fc.Result = res
4875 return ec.marshalNString2string(ctx, field.Selections, res)
4876}
4877
4878func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4879 defer func() {
4880 if r := recover(); r != nil {
4881 ec.Error(ctx, ec.Recover(ctx, r))
4882 ret = graphql.Null
4883 }
4884 }()
4885 fc := &graphql.FieldContext{
4886 Object: "Comment",
4887 Field: field,
4888 Args: nil,
4889 IsMethod: false,
4890 }
4891
4892 ctx = graphql.WithFieldContext(ctx, fc)
4893 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4894 ctx = rctx // use context from middleware stack in children
4895 return obj.Files, nil
4896 })
4897 if err != nil {
4898 ec.Error(ctx, err)
4899 return graphql.Null
4900 }
4901 if resTmp == nil {
4902 if !graphql.HasFieldError(ctx, fc) {
4903 ec.Errorf(ctx, "must not be null")
4904 }
4905 return graphql.Null
4906 }
4907 res := resTmp.([]repository.Hash)
4908 fc.Result = res
4909 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
4910}
4911
4912func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4913 defer func() {
4914 if r := recover(); r != nil {
4915 ec.Error(ctx, ec.Recover(ctx, r))
4916 ret = graphql.Null
4917 }
4918 }()
4919 fc := &graphql.FieldContext{
4920 Object: "CommentConnection",
4921 Field: field,
4922 Args: nil,
4923 IsMethod: false,
4924 }
4925
4926 ctx = graphql.WithFieldContext(ctx, fc)
4927 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4928 ctx = rctx // use context from middleware stack in children
4929 return obj.Edges, nil
4930 })
4931 if err != nil {
4932 ec.Error(ctx, err)
4933 return graphql.Null
4934 }
4935 if resTmp == nil {
4936 if !graphql.HasFieldError(ctx, fc) {
4937 ec.Errorf(ctx, "must not be null")
4938 }
4939 return graphql.Null
4940 }
4941 res := resTmp.([]*models.CommentEdge)
4942 fc.Result = res
4943 return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
4944}
4945
4946func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4947 defer func() {
4948 if r := recover(); r != nil {
4949 ec.Error(ctx, ec.Recover(ctx, r))
4950 ret = graphql.Null
4951 }
4952 }()
4953 fc := &graphql.FieldContext{
4954 Object: "CommentConnection",
4955 Field: field,
4956 Args: nil,
4957 IsMethod: false,
4958 }
4959
4960 ctx = graphql.WithFieldContext(ctx, fc)
4961 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4962 ctx = rctx // use context from middleware stack in children
4963 return obj.Nodes, nil
4964 })
4965 if err != nil {
4966 ec.Error(ctx, err)
4967 return graphql.Null
4968 }
4969 if resTmp == nil {
4970 if !graphql.HasFieldError(ctx, fc) {
4971 ec.Errorf(ctx, "must not be null")
4972 }
4973 return graphql.Null
4974 }
4975 res := resTmp.([]*bug.Comment)
4976 fc.Result = res
4977 return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx, field.Selections, res)
4978}
4979
4980func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
4981 defer func() {
4982 if r := recover(); r != nil {
4983 ec.Error(ctx, ec.Recover(ctx, r))
4984 ret = graphql.Null
4985 }
4986 }()
4987 fc := &graphql.FieldContext{
4988 Object: "CommentConnection",
4989 Field: field,
4990 Args: nil,
4991 IsMethod: false,
4992 }
4993
4994 ctx = graphql.WithFieldContext(ctx, fc)
4995 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4996 ctx = rctx // use context from middleware stack in children
4997 return obj.PageInfo, nil
4998 })
4999 if err != nil {
5000 ec.Error(ctx, err)
5001 return graphql.Null
5002 }
5003 if resTmp == nil {
5004 if !graphql.HasFieldError(ctx, fc) {
5005 ec.Errorf(ctx, "must not be null")
5006 }
5007 return graphql.Null
5008 }
5009 res := resTmp.(*models.PageInfo)
5010 fc.Result = res
5011 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
5012}
5013
5014func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
5015 defer func() {
5016 if r := recover(); r != nil {
5017 ec.Error(ctx, ec.Recover(ctx, r))
5018 ret = graphql.Null
5019 }
5020 }()
5021 fc := &graphql.FieldContext{
5022 Object: "CommentConnection",
5023 Field: field,
5024 Args: nil,
5025 IsMethod: false,
5026 }
5027
5028 ctx = graphql.WithFieldContext(ctx, fc)
5029 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5030 ctx = rctx // use context from middleware stack in children
5031 return obj.TotalCount, nil
5032 })
5033 if err != nil {
5034 ec.Error(ctx, err)
5035 return graphql.Null
5036 }
5037 if resTmp == nil {
5038 if !graphql.HasFieldError(ctx, fc) {
5039 ec.Errorf(ctx, "must not be null")
5040 }
5041 return graphql.Null
5042 }
5043 res := resTmp.(int)
5044 fc.Result = res
5045 return ec.marshalNInt2int(ctx, field.Selections, res)
5046}
5047
5048func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
5049 defer func() {
5050 if r := recover(); r != nil {
5051 ec.Error(ctx, ec.Recover(ctx, r))
5052 ret = graphql.Null
5053 }
5054 }()
5055 fc := &graphql.FieldContext{
5056 Object: "CommentEdge",
5057 Field: field,
5058 Args: nil,
5059 IsMethod: false,
5060 }
5061
5062 ctx = graphql.WithFieldContext(ctx, fc)
5063 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5064 ctx = rctx // use context from middleware stack in children
5065 return obj.Cursor, nil
5066 })
5067 if err != nil {
5068 ec.Error(ctx, err)
5069 return graphql.Null
5070 }
5071 if resTmp == nil {
5072 if !graphql.HasFieldError(ctx, fc) {
5073 ec.Errorf(ctx, "must not be null")
5074 }
5075 return graphql.Null
5076 }
5077 res := resTmp.(string)
5078 fc.Result = res
5079 return ec.marshalNString2string(ctx, field.Selections, res)
5080}
5081
5082func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
5083 defer func() {
5084 if r := recover(); r != nil {
5085 ec.Error(ctx, ec.Recover(ctx, r))
5086 ret = graphql.Null
5087 }
5088 }()
5089 fc := &graphql.FieldContext{
5090 Object: "CommentEdge",
5091 Field: field,
5092 Args: nil,
5093 IsMethod: false,
5094 }
5095
5096 ctx = graphql.WithFieldContext(ctx, fc)
5097 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5098 ctx = rctx // use context from middleware stack in children
5099 return obj.Node, nil
5100 })
5101 if err != nil {
5102 ec.Error(ctx, err)
5103 return graphql.Null
5104 }
5105 if resTmp == nil {
5106 if !graphql.HasFieldError(ctx, fc) {
5107 ec.Errorf(ctx, "must not be null")
5108 }
5109 return graphql.Null
5110 }
5111 res := resTmp.(*bug.Comment)
5112 fc.Result = res
5113 return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
5114}
5115
5116func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
5117 defer func() {
5118 if r := recover(); r != nil {
5119 ec.Error(ctx, ec.Recover(ctx, r))
5120 ret = graphql.Null
5121 }
5122 }()
5123 fc := &graphql.FieldContext{
5124 Object: "CommentHistoryStep",
5125 Field: field,
5126 Args: nil,
5127 IsMethod: false,
5128 }
5129
5130 ctx = graphql.WithFieldContext(ctx, fc)
5131 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5132 ctx = rctx // use context from middleware stack in children
5133 return obj.Message, nil
5134 })
5135 if err != nil {
5136 ec.Error(ctx, err)
5137 return graphql.Null
5138 }
5139 if resTmp == nil {
5140 if !graphql.HasFieldError(ctx, fc) {
5141 ec.Errorf(ctx, "must not be null")
5142 }
5143 return graphql.Null
5144 }
5145 res := resTmp.(string)
5146 fc.Result = res
5147 return ec.marshalNString2string(ctx, field.Selections, res)
5148}
5149
5150func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
5151 defer func() {
5152 if r := recover(); r != nil {
5153 ec.Error(ctx, ec.Recover(ctx, r))
5154 ret = graphql.Null
5155 }
5156 }()
5157 fc := &graphql.FieldContext{
5158 Object: "CommentHistoryStep",
5159 Field: field,
5160 Args: nil,
5161 IsMethod: true,
5162 }
5163
5164 ctx = graphql.WithFieldContext(ctx, fc)
5165 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5166 ctx = rctx // use context from middleware stack in children
5167 return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
5168 })
5169 if err != nil {
5170 ec.Error(ctx, err)
5171 return graphql.Null
5172 }
5173 if resTmp == nil {
5174 if !graphql.HasFieldError(ctx, fc) {
5175 ec.Errorf(ctx, "must not be null")
5176 }
5177 return graphql.Null
5178 }
5179 res := resTmp.(*time.Time)
5180 fc.Result = res
5181 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5182}
5183
5184func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5185 defer func() {
5186 if r := recover(); r != nil {
5187 ec.Error(ctx, ec.Recover(ctx, r))
5188 ret = graphql.Null
5189 }
5190 }()
5191 fc := &graphql.FieldContext{
5192 Object: "CreateOperation",
5193 Field: field,
5194 Args: nil,
5195 IsMethod: true,
5196 }
5197
5198 ctx = graphql.WithFieldContext(ctx, fc)
5199 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5200 ctx = rctx // use context from middleware stack in children
5201 return ec.resolvers.CreateOperation().ID(rctx, obj)
5202 })
5203 if err != nil {
5204 ec.Error(ctx, err)
5205 return graphql.Null
5206 }
5207 if resTmp == nil {
5208 if !graphql.HasFieldError(ctx, fc) {
5209 ec.Errorf(ctx, "must not be null")
5210 }
5211 return graphql.Null
5212 }
5213 res := resTmp.(string)
5214 fc.Result = res
5215 return ec.marshalNString2string(ctx, field.Selections, res)
5216}
5217
5218func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5219 defer func() {
5220 if r := recover(); r != nil {
5221 ec.Error(ctx, ec.Recover(ctx, r))
5222 ret = graphql.Null
5223 }
5224 }()
5225 fc := &graphql.FieldContext{
5226 Object: "CreateOperation",
5227 Field: field,
5228 Args: nil,
5229 IsMethod: true,
5230 }
5231
5232 ctx = graphql.WithFieldContext(ctx, fc)
5233 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5234 ctx = rctx // use context from middleware stack in children
5235 return ec.resolvers.CreateOperation().Author(rctx, obj)
5236 })
5237 if err != nil {
5238 ec.Error(ctx, err)
5239 return graphql.Null
5240 }
5241 if resTmp == nil {
5242 if !graphql.HasFieldError(ctx, fc) {
5243 ec.Errorf(ctx, "must not be null")
5244 }
5245 return graphql.Null
5246 }
5247 res := resTmp.(models.IdentityWrapper)
5248 fc.Result = res
5249 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5250}
5251
5252func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5253 defer func() {
5254 if r := recover(); r != nil {
5255 ec.Error(ctx, ec.Recover(ctx, r))
5256 ret = graphql.Null
5257 }
5258 }()
5259 fc := &graphql.FieldContext{
5260 Object: "CreateOperation",
5261 Field: field,
5262 Args: nil,
5263 IsMethod: true,
5264 }
5265
5266 ctx = graphql.WithFieldContext(ctx, fc)
5267 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5268 ctx = rctx // use context from middleware stack in children
5269 return ec.resolvers.CreateOperation().Date(rctx, obj)
5270 })
5271 if err != nil {
5272 ec.Error(ctx, err)
5273 return graphql.Null
5274 }
5275 if resTmp == nil {
5276 if !graphql.HasFieldError(ctx, fc) {
5277 ec.Errorf(ctx, "must not be null")
5278 }
5279 return graphql.Null
5280 }
5281 res := resTmp.(*time.Time)
5282 fc.Result = res
5283 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5284}
5285
5286func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5287 defer func() {
5288 if r := recover(); r != nil {
5289 ec.Error(ctx, ec.Recover(ctx, r))
5290 ret = graphql.Null
5291 }
5292 }()
5293 fc := &graphql.FieldContext{
5294 Object: "CreateOperation",
5295 Field: field,
5296 Args: nil,
5297 IsMethod: false,
5298 }
5299
5300 ctx = graphql.WithFieldContext(ctx, fc)
5301 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5302 ctx = rctx // use context from middleware stack in children
5303 return obj.Title, nil
5304 })
5305 if err != nil {
5306 ec.Error(ctx, err)
5307 return graphql.Null
5308 }
5309 if resTmp == nil {
5310 if !graphql.HasFieldError(ctx, fc) {
5311 ec.Errorf(ctx, "must not be null")
5312 }
5313 return graphql.Null
5314 }
5315 res := resTmp.(string)
5316 fc.Result = res
5317 return ec.marshalNString2string(ctx, field.Selections, res)
5318}
5319
5320func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5321 defer func() {
5322 if r := recover(); r != nil {
5323 ec.Error(ctx, ec.Recover(ctx, r))
5324 ret = graphql.Null
5325 }
5326 }()
5327 fc := &graphql.FieldContext{
5328 Object: "CreateOperation",
5329 Field: field,
5330 Args: nil,
5331 IsMethod: false,
5332 }
5333
5334 ctx = graphql.WithFieldContext(ctx, fc)
5335 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5336 ctx = rctx // use context from middleware stack in children
5337 return obj.Message, nil
5338 })
5339 if err != nil {
5340 ec.Error(ctx, err)
5341 return graphql.Null
5342 }
5343 if resTmp == nil {
5344 if !graphql.HasFieldError(ctx, fc) {
5345 ec.Errorf(ctx, "must not be null")
5346 }
5347 return graphql.Null
5348 }
5349 res := resTmp.(string)
5350 fc.Result = res
5351 return ec.marshalNString2string(ctx, field.Selections, res)
5352}
5353
5354func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5355 defer func() {
5356 if r := recover(); r != nil {
5357 ec.Error(ctx, ec.Recover(ctx, r))
5358 ret = graphql.Null
5359 }
5360 }()
5361 fc := &graphql.FieldContext{
5362 Object: "CreateOperation",
5363 Field: field,
5364 Args: nil,
5365 IsMethod: false,
5366 }
5367
5368 ctx = graphql.WithFieldContext(ctx, fc)
5369 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5370 ctx = rctx // use context from middleware stack in children
5371 return obj.Files, nil
5372 })
5373 if err != nil {
5374 ec.Error(ctx, err)
5375 return graphql.Null
5376 }
5377 if resTmp == nil {
5378 if !graphql.HasFieldError(ctx, fc) {
5379 ec.Errorf(ctx, "must not be null")
5380 }
5381 return graphql.Null
5382 }
5383 res := resTmp.([]repository.Hash)
5384 fc.Result = res
5385 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
5386}
5387
5388func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5389 defer func() {
5390 if r := recover(); r != nil {
5391 ec.Error(ctx, ec.Recover(ctx, r))
5392 ret = graphql.Null
5393 }
5394 }()
5395 fc := &graphql.FieldContext{
5396 Object: "CreateTimelineItem",
5397 Field: field,
5398 Args: nil,
5399 IsMethod: true,
5400 }
5401
5402 ctx = graphql.WithFieldContext(ctx, fc)
5403 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5404 ctx = rctx // use context from middleware stack in children
5405 return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
5406 })
5407 if err != nil {
5408 ec.Error(ctx, err)
5409 return graphql.Null
5410 }
5411 if resTmp == nil {
5412 if !graphql.HasFieldError(ctx, fc) {
5413 ec.Errorf(ctx, "must not be null")
5414 }
5415 return graphql.Null
5416 }
5417 res := resTmp.(string)
5418 fc.Result = res
5419 return ec.marshalNString2string(ctx, field.Selections, res)
5420}
5421
5422func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5423 defer func() {
5424 if r := recover(); r != nil {
5425 ec.Error(ctx, ec.Recover(ctx, r))
5426 ret = graphql.Null
5427 }
5428 }()
5429 fc := &graphql.FieldContext{
5430 Object: "CreateTimelineItem",
5431 Field: field,
5432 Args: nil,
5433 IsMethod: true,
5434 }
5435
5436 ctx = graphql.WithFieldContext(ctx, fc)
5437 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5438 ctx = rctx // use context from middleware stack in children
5439 return ec.resolvers.CreateTimelineItem().Author(rctx, obj)
5440 })
5441 if err != nil {
5442 ec.Error(ctx, err)
5443 return graphql.Null
5444 }
5445 if resTmp == nil {
5446 if !graphql.HasFieldError(ctx, fc) {
5447 ec.Errorf(ctx, "must not be null")
5448 }
5449 return graphql.Null
5450 }
5451 res := resTmp.(models.IdentityWrapper)
5452 fc.Result = res
5453 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5454}
5455
5456func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5457 defer func() {
5458 if r := recover(); r != nil {
5459 ec.Error(ctx, ec.Recover(ctx, r))
5460 ret = graphql.Null
5461 }
5462 }()
5463 fc := &graphql.FieldContext{
5464 Object: "CreateTimelineItem",
5465 Field: field,
5466 Args: nil,
5467 IsMethod: false,
5468 }
5469
5470 ctx = graphql.WithFieldContext(ctx, fc)
5471 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5472 ctx = rctx // use context from middleware stack in children
5473 return obj.Message, nil
5474 })
5475 if err != nil {
5476 ec.Error(ctx, err)
5477 return graphql.Null
5478 }
5479 if resTmp == nil {
5480 if !graphql.HasFieldError(ctx, fc) {
5481 ec.Errorf(ctx, "must not be null")
5482 }
5483 return graphql.Null
5484 }
5485 res := resTmp.(string)
5486 fc.Result = res
5487 return ec.marshalNString2string(ctx, field.Selections, res)
5488}
5489
5490func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5491 defer func() {
5492 if r := recover(); r != nil {
5493 ec.Error(ctx, ec.Recover(ctx, r))
5494 ret = graphql.Null
5495 }
5496 }()
5497 fc := &graphql.FieldContext{
5498 Object: "CreateTimelineItem",
5499 Field: field,
5500 Args: nil,
5501 IsMethod: true,
5502 }
5503
5504 ctx = graphql.WithFieldContext(ctx, fc)
5505 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5506 ctx = rctx // use context from middleware stack in children
5507 return obj.MessageIsEmpty(), nil
5508 })
5509 if err != nil {
5510 ec.Error(ctx, err)
5511 return graphql.Null
5512 }
5513 if resTmp == nil {
5514 if !graphql.HasFieldError(ctx, fc) {
5515 ec.Errorf(ctx, "must not be null")
5516 }
5517 return graphql.Null
5518 }
5519 res := resTmp.(bool)
5520 fc.Result = res
5521 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5522}
5523
5524func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5525 defer func() {
5526 if r := recover(); r != nil {
5527 ec.Error(ctx, ec.Recover(ctx, r))
5528 ret = graphql.Null
5529 }
5530 }()
5531 fc := &graphql.FieldContext{
5532 Object: "CreateTimelineItem",
5533 Field: field,
5534 Args: nil,
5535 IsMethod: false,
5536 }
5537
5538 ctx = graphql.WithFieldContext(ctx, fc)
5539 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5540 ctx = rctx // use context from middleware stack in children
5541 return obj.Files, nil
5542 })
5543 if err != nil {
5544 ec.Error(ctx, err)
5545 return graphql.Null
5546 }
5547 if resTmp == nil {
5548 if !graphql.HasFieldError(ctx, fc) {
5549 ec.Errorf(ctx, "must not be null")
5550 }
5551 return graphql.Null
5552 }
5553 res := resTmp.([]repository.Hash)
5554 fc.Result = res
5555 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
5556}
5557
5558func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5559 defer func() {
5560 if r := recover(); r != nil {
5561 ec.Error(ctx, ec.Recover(ctx, r))
5562 ret = graphql.Null
5563 }
5564 }()
5565 fc := &graphql.FieldContext{
5566 Object: "CreateTimelineItem",
5567 Field: field,
5568 Args: nil,
5569 IsMethod: true,
5570 }
5571
5572 ctx = graphql.WithFieldContext(ctx, fc)
5573 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5574 ctx = rctx // use context from middleware stack in children
5575 return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
5576 })
5577 if err != nil {
5578 ec.Error(ctx, err)
5579 return graphql.Null
5580 }
5581 if resTmp == nil {
5582 if !graphql.HasFieldError(ctx, fc) {
5583 ec.Errorf(ctx, "must not be null")
5584 }
5585 return graphql.Null
5586 }
5587 res := resTmp.(*time.Time)
5588 fc.Result = res
5589 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5590}
5591
5592func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5593 defer func() {
5594 if r := recover(); r != nil {
5595 ec.Error(ctx, ec.Recover(ctx, r))
5596 ret = graphql.Null
5597 }
5598 }()
5599 fc := &graphql.FieldContext{
5600 Object: "CreateTimelineItem",
5601 Field: field,
5602 Args: nil,
5603 IsMethod: true,
5604 }
5605
5606 ctx = graphql.WithFieldContext(ctx, fc)
5607 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5608 ctx = rctx // use context from middleware stack in children
5609 return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
5610 })
5611 if err != nil {
5612 ec.Error(ctx, err)
5613 return graphql.Null
5614 }
5615 if resTmp == nil {
5616 if !graphql.HasFieldError(ctx, fc) {
5617 ec.Errorf(ctx, "must not be null")
5618 }
5619 return graphql.Null
5620 }
5621 res := resTmp.(*time.Time)
5622 fc.Result = res
5623 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5624}
5625
5626func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5627 defer func() {
5628 if r := recover(); r != nil {
5629 ec.Error(ctx, ec.Recover(ctx, r))
5630 ret = graphql.Null
5631 }
5632 }()
5633 fc := &graphql.FieldContext{
5634 Object: "CreateTimelineItem",
5635 Field: field,
5636 Args: nil,
5637 IsMethod: true,
5638 }
5639
5640 ctx = graphql.WithFieldContext(ctx, fc)
5641 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5642 ctx = rctx // use context from middleware stack in children
5643 return obj.Edited(), nil
5644 })
5645 if err != nil {
5646 ec.Error(ctx, err)
5647 return graphql.Null
5648 }
5649 if resTmp == nil {
5650 if !graphql.HasFieldError(ctx, fc) {
5651 ec.Errorf(ctx, "must not be null")
5652 }
5653 return graphql.Null
5654 }
5655 res := resTmp.(bool)
5656 fc.Result = res
5657 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5658}
5659
5660func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5661 defer func() {
5662 if r := recover(); r != nil {
5663 ec.Error(ctx, ec.Recover(ctx, r))
5664 ret = graphql.Null
5665 }
5666 }()
5667 fc := &graphql.FieldContext{
5668 Object: "CreateTimelineItem",
5669 Field: field,
5670 Args: nil,
5671 IsMethod: false,
5672 }
5673
5674 ctx = graphql.WithFieldContext(ctx, fc)
5675 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5676 ctx = rctx // use context from middleware stack in children
5677 return obj.History, nil
5678 })
5679 if err != nil {
5680 ec.Error(ctx, err)
5681 return graphql.Null
5682 }
5683 if resTmp == nil {
5684 if !graphql.HasFieldError(ctx, fc) {
5685 ec.Errorf(ctx, "must not be null")
5686 }
5687 return graphql.Null
5688 }
5689 res := resTmp.([]bug.CommentHistoryStep)
5690 fc.Result = res
5691 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
5692}
5693
5694func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5695 defer func() {
5696 if r := recover(); r != nil {
5697 ec.Error(ctx, ec.Recover(ctx, r))
5698 ret = graphql.Null
5699 }
5700 }()
5701 fc := &graphql.FieldContext{
5702 Object: "EditCommentOperation",
5703 Field: field,
5704 Args: nil,
5705 IsMethod: true,
5706 }
5707
5708 ctx = graphql.WithFieldContext(ctx, fc)
5709 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5710 ctx = rctx // use context from middleware stack in children
5711 return ec.resolvers.EditCommentOperation().ID(rctx, obj)
5712 })
5713 if err != nil {
5714 ec.Error(ctx, err)
5715 return graphql.Null
5716 }
5717 if resTmp == nil {
5718 if !graphql.HasFieldError(ctx, fc) {
5719 ec.Errorf(ctx, "must not be null")
5720 }
5721 return graphql.Null
5722 }
5723 res := resTmp.(string)
5724 fc.Result = res
5725 return ec.marshalNString2string(ctx, field.Selections, res)
5726}
5727
5728func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5729 defer func() {
5730 if r := recover(); r != nil {
5731 ec.Error(ctx, ec.Recover(ctx, r))
5732 ret = graphql.Null
5733 }
5734 }()
5735 fc := &graphql.FieldContext{
5736 Object: "EditCommentOperation",
5737 Field: field,
5738 Args: nil,
5739 IsMethod: true,
5740 }
5741
5742 ctx = graphql.WithFieldContext(ctx, fc)
5743 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5744 ctx = rctx // use context from middleware stack in children
5745 return ec.resolvers.EditCommentOperation().Author(rctx, obj)
5746 })
5747 if err != nil {
5748 ec.Error(ctx, err)
5749 return graphql.Null
5750 }
5751 if resTmp == nil {
5752 if !graphql.HasFieldError(ctx, fc) {
5753 ec.Errorf(ctx, "must not be null")
5754 }
5755 return graphql.Null
5756 }
5757 res := resTmp.(models.IdentityWrapper)
5758 fc.Result = res
5759 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5760}
5761
5762func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5763 defer func() {
5764 if r := recover(); r != nil {
5765 ec.Error(ctx, ec.Recover(ctx, r))
5766 ret = graphql.Null
5767 }
5768 }()
5769 fc := &graphql.FieldContext{
5770 Object: "EditCommentOperation",
5771 Field: field,
5772 Args: nil,
5773 IsMethod: true,
5774 }
5775
5776 ctx = graphql.WithFieldContext(ctx, fc)
5777 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5778 ctx = rctx // use context from middleware stack in children
5779 return ec.resolvers.EditCommentOperation().Date(rctx, obj)
5780 })
5781 if err != nil {
5782 ec.Error(ctx, err)
5783 return graphql.Null
5784 }
5785 if resTmp == nil {
5786 if !graphql.HasFieldError(ctx, fc) {
5787 ec.Errorf(ctx, "must not be null")
5788 }
5789 return graphql.Null
5790 }
5791 res := resTmp.(*time.Time)
5792 fc.Result = res
5793 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5794}
5795
5796func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5797 defer func() {
5798 if r := recover(); r != nil {
5799 ec.Error(ctx, ec.Recover(ctx, r))
5800 ret = graphql.Null
5801 }
5802 }()
5803 fc := &graphql.FieldContext{
5804 Object: "EditCommentOperation",
5805 Field: field,
5806 Args: nil,
5807 IsMethod: true,
5808 }
5809
5810 ctx = graphql.WithFieldContext(ctx, fc)
5811 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5812 ctx = rctx // use context from middleware stack in children
5813 return ec.resolvers.EditCommentOperation().Target(rctx, obj)
5814 })
5815 if err != nil {
5816 ec.Error(ctx, err)
5817 return graphql.Null
5818 }
5819 if resTmp == nil {
5820 if !graphql.HasFieldError(ctx, fc) {
5821 ec.Errorf(ctx, "must not be null")
5822 }
5823 return graphql.Null
5824 }
5825 res := resTmp.(string)
5826 fc.Result = res
5827 return ec.marshalNString2string(ctx, field.Selections, res)
5828}
5829
5830func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5831 defer func() {
5832 if r := recover(); r != nil {
5833 ec.Error(ctx, ec.Recover(ctx, r))
5834 ret = graphql.Null
5835 }
5836 }()
5837 fc := &graphql.FieldContext{
5838 Object: "EditCommentOperation",
5839 Field: field,
5840 Args: nil,
5841 IsMethod: false,
5842 }
5843
5844 ctx = graphql.WithFieldContext(ctx, fc)
5845 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5846 ctx = rctx // use context from middleware stack in children
5847 return obj.Message, nil
5848 })
5849 if err != nil {
5850 ec.Error(ctx, err)
5851 return graphql.Null
5852 }
5853 if resTmp == nil {
5854 if !graphql.HasFieldError(ctx, fc) {
5855 ec.Errorf(ctx, "must not be null")
5856 }
5857 return graphql.Null
5858 }
5859 res := resTmp.(string)
5860 fc.Result = res
5861 return ec.marshalNString2string(ctx, field.Selections, res)
5862}
5863
5864func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5865 defer func() {
5866 if r := recover(); r != nil {
5867 ec.Error(ctx, ec.Recover(ctx, r))
5868 ret = graphql.Null
5869 }
5870 }()
5871 fc := &graphql.FieldContext{
5872 Object: "EditCommentOperation",
5873 Field: field,
5874 Args: nil,
5875 IsMethod: false,
5876 }
5877
5878 ctx = graphql.WithFieldContext(ctx, fc)
5879 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5880 ctx = rctx // use context from middleware stack in children
5881 return obj.Files, nil
5882 })
5883 if err != nil {
5884 ec.Error(ctx, err)
5885 return graphql.Null
5886 }
5887 if resTmp == nil {
5888 if !graphql.HasFieldError(ctx, fc) {
5889 ec.Errorf(ctx, "must not be null")
5890 }
5891 return graphql.Null
5892 }
5893 res := resTmp.([]repository.Hash)
5894 fc.Result = res
5895 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
5896}
5897
5898func (ec *executionContext) _EditCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
5899 defer func() {
5900 if r := recover(); r != nil {
5901 ec.Error(ctx, ec.Recover(ctx, r))
5902 ret = graphql.Null
5903 }
5904 }()
5905 fc := &graphql.FieldContext{
5906 Object: "EditCommentPayload",
5907 Field: field,
5908 Args: nil,
5909 IsMethod: false,
5910 }
5911
5912 ctx = graphql.WithFieldContext(ctx, fc)
5913 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5914 ctx = rctx // use context from middleware stack in children
5915 return obj.ClientMutationID, nil
5916 })
5917 if err != nil {
5918 ec.Error(ctx, err)
5919 return graphql.Null
5920 }
5921 if resTmp == nil {
5922 return graphql.Null
5923 }
5924 res := resTmp.(*string)
5925 fc.Result = res
5926 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
5927}
5928
5929func (ec *executionContext) _EditCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
5930 defer func() {
5931 if r := recover(); r != nil {
5932 ec.Error(ctx, ec.Recover(ctx, r))
5933 ret = graphql.Null
5934 }
5935 }()
5936 fc := &graphql.FieldContext{
5937 Object: "EditCommentPayload",
5938 Field: field,
5939 Args: nil,
5940 IsMethod: false,
5941 }
5942
5943 ctx = graphql.WithFieldContext(ctx, fc)
5944 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5945 ctx = rctx // use context from middleware stack in children
5946 return obj.Bug, nil
5947 })
5948 if err != nil {
5949 ec.Error(ctx, err)
5950 return graphql.Null
5951 }
5952 if resTmp == nil {
5953 if !graphql.HasFieldError(ctx, fc) {
5954 ec.Errorf(ctx, "must not be null")
5955 }
5956 return graphql.Null
5957 }
5958 res := resTmp.(models.BugWrapper)
5959 fc.Result = res
5960 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
5961}
5962
5963func (ec *executionContext) _EditCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
5964 defer func() {
5965 if r := recover(); r != nil {
5966 ec.Error(ctx, ec.Recover(ctx, r))
5967 ret = graphql.Null
5968 }
5969 }()
5970 fc := &graphql.FieldContext{
5971 Object: "EditCommentPayload",
5972 Field: field,
5973 Args: nil,
5974 IsMethod: false,
5975 }
5976
5977 ctx = graphql.WithFieldContext(ctx, fc)
5978 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5979 ctx = rctx // use context from middleware stack in children
5980 return obj.Operation, nil
5981 })
5982 if err != nil {
5983 ec.Error(ctx, err)
5984 return graphql.Null
5985 }
5986 if resTmp == nil {
5987 if !graphql.HasFieldError(ctx, fc) {
5988 ec.Errorf(ctx, "must not be null")
5989 }
5990 return graphql.Null
5991 }
5992 res := resTmp.(*bug.EditCommentOperation)
5993 fc.Result = res
5994 return ec.marshalNEditCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐEditCommentOperation(ctx, field.Selections, res)
5995}
5996
5997func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
5998 defer func() {
5999 if r := recover(); r != nil {
6000 ec.Error(ctx, ec.Recover(ctx, r))
6001 ret = graphql.Null
6002 }
6003 }()
6004 fc := &graphql.FieldContext{
6005 Object: "Identity",
6006 Field: field,
6007 Args: nil,
6008 IsMethod: true,
6009 }
6010
6011 ctx = graphql.WithFieldContext(ctx, fc)
6012 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6013 ctx = rctx // use context from middleware stack in children
6014 return ec.resolvers.Identity().ID(rctx, obj)
6015 })
6016 if err != nil {
6017 ec.Error(ctx, err)
6018 return graphql.Null
6019 }
6020 if resTmp == nil {
6021 if !graphql.HasFieldError(ctx, fc) {
6022 ec.Errorf(ctx, "must not be null")
6023 }
6024 return graphql.Null
6025 }
6026 res := resTmp.(string)
6027 fc.Result = res
6028 return ec.marshalNString2string(ctx, field.Selections, res)
6029}
6030
6031func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6032 defer func() {
6033 if r := recover(); r != nil {
6034 ec.Error(ctx, ec.Recover(ctx, r))
6035 ret = graphql.Null
6036 }
6037 }()
6038 fc := &graphql.FieldContext{
6039 Object: "Identity",
6040 Field: field,
6041 Args: nil,
6042 IsMethod: true,
6043 }
6044
6045 ctx = graphql.WithFieldContext(ctx, fc)
6046 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6047 ctx = rctx // use context from middleware stack in children
6048 return ec.resolvers.Identity().HumanID(rctx, obj)
6049 })
6050 if err != nil {
6051 ec.Error(ctx, err)
6052 return graphql.Null
6053 }
6054 if resTmp == nil {
6055 if !graphql.HasFieldError(ctx, fc) {
6056 ec.Errorf(ctx, "must not be null")
6057 }
6058 return graphql.Null
6059 }
6060 res := resTmp.(string)
6061 fc.Result = res
6062 return ec.marshalNString2string(ctx, field.Selections, res)
6063}
6064
6065func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6066 defer func() {
6067 if r := recover(); r != nil {
6068 ec.Error(ctx, ec.Recover(ctx, r))
6069 ret = graphql.Null
6070 }
6071 }()
6072 fc := &graphql.FieldContext{
6073 Object: "Identity",
6074 Field: field,
6075 Args: nil,
6076 IsMethod: true,
6077 }
6078
6079 ctx = graphql.WithFieldContext(ctx, fc)
6080 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6081 ctx = rctx // use context from middleware stack in children
6082 return obj.Name(), nil
6083 })
6084 if err != nil {
6085 ec.Error(ctx, err)
6086 return graphql.Null
6087 }
6088 if resTmp == nil {
6089 return graphql.Null
6090 }
6091 res := resTmp.(string)
6092 fc.Result = res
6093 return ec.marshalOString2string(ctx, field.Selections, res)
6094}
6095
6096func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6097 defer func() {
6098 if r := recover(); r != nil {
6099 ec.Error(ctx, ec.Recover(ctx, r))
6100 ret = graphql.Null
6101 }
6102 }()
6103 fc := &graphql.FieldContext{
6104 Object: "Identity",
6105 Field: field,
6106 Args: nil,
6107 IsMethod: true,
6108 }
6109
6110 ctx = graphql.WithFieldContext(ctx, fc)
6111 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6112 ctx = rctx // use context from middleware stack in children
6113 return obj.Email()
6114 })
6115 if err != nil {
6116 ec.Error(ctx, err)
6117 return graphql.Null
6118 }
6119 if resTmp == nil {
6120 return graphql.Null
6121 }
6122 res := resTmp.(string)
6123 fc.Result = res
6124 return ec.marshalOString2string(ctx, field.Selections, res)
6125}
6126
6127func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6128 defer func() {
6129 if r := recover(); r != nil {
6130 ec.Error(ctx, ec.Recover(ctx, r))
6131 ret = graphql.Null
6132 }
6133 }()
6134 fc := &graphql.FieldContext{
6135 Object: "Identity",
6136 Field: field,
6137 Args: nil,
6138 IsMethod: true,
6139 }
6140
6141 ctx = graphql.WithFieldContext(ctx, fc)
6142 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6143 ctx = rctx // use context from middleware stack in children
6144 return obj.Login()
6145 })
6146 if err != nil {
6147 ec.Error(ctx, err)
6148 return graphql.Null
6149 }
6150 if resTmp == nil {
6151 return graphql.Null
6152 }
6153 res := resTmp.(string)
6154 fc.Result = res
6155 return ec.marshalOString2string(ctx, field.Selections, res)
6156}
6157
6158func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6159 defer func() {
6160 if r := recover(); r != nil {
6161 ec.Error(ctx, ec.Recover(ctx, r))
6162 ret = graphql.Null
6163 }
6164 }()
6165 fc := &graphql.FieldContext{
6166 Object: "Identity",
6167 Field: field,
6168 Args: nil,
6169 IsMethod: true,
6170 }
6171
6172 ctx = graphql.WithFieldContext(ctx, fc)
6173 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6174 ctx = rctx // use context from middleware stack in children
6175 return obj.DisplayName(), nil
6176 })
6177 if err != nil {
6178 ec.Error(ctx, err)
6179 return graphql.Null
6180 }
6181 if resTmp == nil {
6182 if !graphql.HasFieldError(ctx, fc) {
6183 ec.Errorf(ctx, "must not be null")
6184 }
6185 return graphql.Null
6186 }
6187 res := resTmp.(string)
6188 fc.Result = res
6189 return ec.marshalNString2string(ctx, field.Selections, res)
6190}
6191
6192func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6193 defer func() {
6194 if r := recover(); r != nil {
6195 ec.Error(ctx, ec.Recover(ctx, r))
6196 ret = graphql.Null
6197 }
6198 }()
6199 fc := &graphql.FieldContext{
6200 Object: "Identity",
6201 Field: field,
6202 Args: nil,
6203 IsMethod: true,
6204 }
6205
6206 ctx = graphql.WithFieldContext(ctx, fc)
6207 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6208 ctx = rctx // use context from middleware stack in children
6209 return obj.AvatarUrl()
6210 })
6211 if err != nil {
6212 ec.Error(ctx, err)
6213 return graphql.Null
6214 }
6215 if resTmp == nil {
6216 return graphql.Null
6217 }
6218 res := resTmp.(string)
6219 fc.Result = res
6220 return ec.marshalOString2string(ctx, field.Selections, res)
6221}
6222
6223func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6224 defer func() {
6225 if r := recover(); r != nil {
6226 ec.Error(ctx, ec.Recover(ctx, r))
6227 ret = graphql.Null
6228 }
6229 }()
6230 fc := &graphql.FieldContext{
6231 Object: "Identity",
6232 Field: field,
6233 Args: nil,
6234 IsMethod: true,
6235 }
6236
6237 ctx = graphql.WithFieldContext(ctx, fc)
6238 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6239 ctx = rctx // use context from middleware stack in children
6240 return obj.IsProtected()
6241 })
6242 if err != nil {
6243 ec.Error(ctx, err)
6244 return graphql.Null
6245 }
6246 if resTmp == nil {
6247 if !graphql.HasFieldError(ctx, fc) {
6248 ec.Errorf(ctx, "must not be null")
6249 }
6250 return graphql.Null
6251 }
6252 res := resTmp.(bool)
6253 fc.Result = res
6254 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
6255}
6256
6257func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6258 defer func() {
6259 if r := recover(); r != nil {
6260 ec.Error(ctx, ec.Recover(ctx, r))
6261 ret = graphql.Null
6262 }
6263 }()
6264 fc := &graphql.FieldContext{
6265 Object: "IdentityConnection",
6266 Field: field,
6267 Args: nil,
6268 IsMethod: false,
6269 }
6270
6271 ctx = graphql.WithFieldContext(ctx, fc)
6272 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6273 ctx = rctx // use context from middleware stack in children
6274 return obj.Edges, nil
6275 })
6276 if err != nil {
6277 ec.Error(ctx, err)
6278 return graphql.Null
6279 }
6280 if resTmp == nil {
6281 if !graphql.HasFieldError(ctx, fc) {
6282 ec.Errorf(ctx, "must not be null")
6283 }
6284 return graphql.Null
6285 }
6286 res := resTmp.([]*models.IdentityEdge)
6287 fc.Result = res
6288 return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx, field.Selections, res)
6289}
6290
6291func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6292 defer func() {
6293 if r := recover(); r != nil {
6294 ec.Error(ctx, ec.Recover(ctx, r))
6295 ret = graphql.Null
6296 }
6297 }()
6298 fc := &graphql.FieldContext{
6299 Object: "IdentityConnection",
6300 Field: field,
6301 Args: nil,
6302 IsMethod: false,
6303 }
6304
6305 ctx = graphql.WithFieldContext(ctx, fc)
6306 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6307 ctx = rctx // use context from middleware stack in children
6308 return obj.Nodes, nil
6309 })
6310 if err != nil {
6311 ec.Error(ctx, err)
6312 return graphql.Null
6313 }
6314 if resTmp == nil {
6315 if !graphql.HasFieldError(ctx, fc) {
6316 ec.Errorf(ctx, "must not be null")
6317 }
6318 return graphql.Null
6319 }
6320 res := resTmp.([]models.IdentityWrapper)
6321 fc.Result = res
6322 return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx, field.Selections, res)
6323}
6324
6325func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6326 defer func() {
6327 if r := recover(); r != nil {
6328 ec.Error(ctx, ec.Recover(ctx, r))
6329 ret = graphql.Null
6330 }
6331 }()
6332 fc := &graphql.FieldContext{
6333 Object: "IdentityConnection",
6334 Field: field,
6335 Args: nil,
6336 IsMethod: false,
6337 }
6338
6339 ctx = graphql.WithFieldContext(ctx, fc)
6340 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6341 ctx = rctx // use context from middleware stack in children
6342 return obj.PageInfo, nil
6343 })
6344 if err != nil {
6345 ec.Error(ctx, err)
6346 return graphql.Null
6347 }
6348 if resTmp == nil {
6349 if !graphql.HasFieldError(ctx, fc) {
6350 ec.Errorf(ctx, "must not be null")
6351 }
6352 return graphql.Null
6353 }
6354 res := resTmp.(*models.PageInfo)
6355 fc.Result = res
6356 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
6357}
6358
6359func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6360 defer func() {
6361 if r := recover(); r != nil {
6362 ec.Error(ctx, ec.Recover(ctx, r))
6363 ret = graphql.Null
6364 }
6365 }()
6366 fc := &graphql.FieldContext{
6367 Object: "IdentityConnection",
6368 Field: field,
6369 Args: nil,
6370 IsMethod: false,
6371 }
6372
6373 ctx = graphql.WithFieldContext(ctx, fc)
6374 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6375 ctx = rctx // use context from middleware stack in children
6376 return obj.TotalCount, nil
6377 })
6378 if err != nil {
6379 ec.Error(ctx, err)
6380 return graphql.Null
6381 }
6382 if resTmp == nil {
6383 if !graphql.HasFieldError(ctx, fc) {
6384 ec.Errorf(ctx, "must not be null")
6385 }
6386 return graphql.Null
6387 }
6388 res := resTmp.(int)
6389 fc.Result = res
6390 return ec.marshalNInt2int(ctx, field.Selections, res)
6391}
6392
6393func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6394 defer func() {
6395 if r := recover(); r != nil {
6396 ec.Error(ctx, ec.Recover(ctx, r))
6397 ret = graphql.Null
6398 }
6399 }()
6400 fc := &graphql.FieldContext{
6401 Object: "IdentityEdge",
6402 Field: field,
6403 Args: nil,
6404 IsMethod: false,
6405 }
6406
6407 ctx = graphql.WithFieldContext(ctx, fc)
6408 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6409 ctx = rctx // use context from middleware stack in children
6410 return obj.Cursor, nil
6411 })
6412 if err != nil {
6413 ec.Error(ctx, err)
6414 return graphql.Null
6415 }
6416 if resTmp == nil {
6417 if !graphql.HasFieldError(ctx, fc) {
6418 ec.Errorf(ctx, "must not be null")
6419 }
6420 return graphql.Null
6421 }
6422 res := resTmp.(string)
6423 fc.Result = res
6424 return ec.marshalNString2string(ctx, field.Selections, res)
6425}
6426
6427func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6428 defer func() {
6429 if r := recover(); r != nil {
6430 ec.Error(ctx, ec.Recover(ctx, r))
6431 ret = graphql.Null
6432 }
6433 }()
6434 fc := &graphql.FieldContext{
6435 Object: "IdentityEdge",
6436 Field: field,
6437 Args: nil,
6438 IsMethod: false,
6439 }
6440
6441 ctx = graphql.WithFieldContext(ctx, fc)
6442 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6443 ctx = rctx // use context from middleware stack in children
6444 return obj.Node, nil
6445 })
6446 if err != nil {
6447 ec.Error(ctx, err)
6448 return graphql.Null
6449 }
6450 if resTmp == nil {
6451 if !graphql.HasFieldError(ctx, fc) {
6452 ec.Errorf(ctx, "must not be null")
6453 }
6454 return graphql.Null
6455 }
6456 res := resTmp.(models.IdentityWrapper)
6457 fc.Result = res
6458 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6459}
6460
6461func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6462 defer func() {
6463 if r := recover(); r != nil {
6464 ec.Error(ctx, ec.Recover(ctx, r))
6465 ret = graphql.Null
6466 }
6467 }()
6468 fc := &graphql.FieldContext{
6469 Object: "Label",
6470 Field: field,
6471 Args: nil,
6472 IsMethod: true,
6473 }
6474
6475 ctx = graphql.WithFieldContext(ctx, fc)
6476 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6477 ctx = rctx // use context from middleware stack in children
6478 return ec.resolvers.Label().Name(rctx, obj)
6479 })
6480 if err != nil {
6481 ec.Error(ctx, err)
6482 return graphql.Null
6483 }
6484 if resTmp == nil {
6485 if !graphql.HasFieldError(ctx, fc) {
6486 ec.Errorf(ctx, "must not be null")
6487 }
6488 return graphql.Null
6489 }
6490 res := resTmp.(string)
6491 fc.Result = res
6492 return ec.marshalNString2string(ctx, field.Selections, res)
6493}
6494
6495func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6496 defer func() {
6497 if r := recover(); r != nil {
6498 ec.Error(ctx, ec.Recover(ctx, r))
6499 ret = graphql.Null
6500 }
6501 }()
6502 fc := &graphql.FieldContext{
6503 Object: "Label",
6504 Field: field,
6505 Args: nil,
6506 IsMethod: true,
6507 }
6508
6509 ctx = graphql.WithFieldContext(ctx, fc)
6510 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6511 ctx = rctx // use context from middleware stack in children
6512 return ec.resolvers.Label().Color(rctx, obj)
6513 })
6514 if err != nil {
6515 ec.Error(ctx, err)
6516 return graphql.Null
6517 }
6518 if resTmp == nil {
6519 if !graphql.HasFieldError(ctx, fc) {
6520 ec.Errorf(ctx, "must not be null")
6521 }
6522 return graphql.Null
6523 }
6524 res := resTmp.(*color.RGBA)
6525 fc.Result = res
6526 return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
6527}
6528
6529func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6530 defer func() {
6531 if r := recover(); r != nil {
6532 ec.Error(ctx, ec.Recover(ctx, r))
6533 ret = graphql.Null
6534 }
6535 }()
6536 fc := &graphql.FieldContext{
6537 Object: "LabelChangeOperation",
6538 Field: field,
6539 Args: nil,
6540 IsMethod: true,
6541 }
6542
6543 ctx = graphql.WithFieldContext(ctx, fc)
6544 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6545 ctx = rctx // use context from middleware stack in children
6546 return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
6547 })
6548 if err != nil {
6549 ec.Error(ctx, err)
6550 return graphql.Null
6551 }
6552 if resTmp == nil {
6553 if !graphql.HasFieldError(ctx, fc) {
6554 ec.Errorf(ctx, "must not be null")
6555 }
6556 return graphql.Null
6557 }
6558 res := resTmp.(string)
6559 fc.Result = res
6560 return ec.marshalNString2string(ctx, field.Selections, res)
6561}
6562
6563func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6564 defer func() {
6565 if r := recover(); r != nil {
6566 ec.Error(ctx, ec.Recover(ctx, r))
6567 ret = graphql.Null
6568 }
6569 }()
6570 fc := &graphql.FieldContext{
6571 Object: "LabelChangeOperation",
6572 Field: field,
6573 Args: nil,
6574 IsMethod: true,
6575 }
6576
6577 ctx = graphql.WithFieldContext(ctx, fc)
6578 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6579 ctx = rctx // use context from middleware stack in children
6580 return ec.resolvers.LabelChangeOperation().Author(rctx, obj)
6581 })
6582 if err != nil {
6583 ec.Error(ctx, err)
6584 return graphql.Null
6585 }
6586 if resTmp == nil {
6587 if !graphql.HasFieldError(ctx, fc) {
6588 ec.Errorf(ctx, "must not be null")
6589 }
6590 return graphql.Null
6591 }
6592 res := resTmp.(models.IdentityWrapper)
6593 fc.Result = res
6594 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6595}
6596
6597func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6598 defer func() {
6599 if r := recover(); r != nil {
6600 ec.Error(ctx, ec.Recover(ctx, r))
6601 ret = graphql.Null
6602 }
6603 }()
6604 fc := &graphql.FieldContext{
6605 Object: "LabelChangeOperation",
6606 Field: field,
6607 Args: nil,
6608 IsMethod: true,
6609 }
6610
6611 ctx = graphql.WithFieldContext(ctx, fc)
6612 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6613 ctx = rctx // use context from middleware stack in children
6614 return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
6615 })
6616 if err != nil {
6617 ec.Error(ctx, err)
6618 return graphql.Null
6619 }
6620 if resTmp == nil {
6621 if !graphql.HasFieldError(ctx, fc) {
6622 ec.Errorf(ctx, "must not be null")
6623 }
6624 return graphql.Null
6625 }
6626 res := resTmp.(*time.Time)
6627 fc.Result = res
6628 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6629}
6630
6631func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6632 defer func() {
6633 if r := recover(); r != nil {
6634 ec.Error(ctx, ec.Recover(ctx, r))
6635 ret = graphql.Null
6636 }
6637 }()
6638 fc := &graphql.FieldContext{
6639 Object: "LabelChangeOperation",
6640 Field: field,
6641 Args: nil,
6642 IsMethod: false,
6643 }
6644
6645 ctx = graphql.WithFieldContext(ctx, fc)
6646 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6647 ctx = rctx // use context from middleware stack in children
6648 return obj.Added, nil
6649 })
6650 if err != nil {
6651 ec.Error(ctx, err)
6652 return graphql.Null
6653 }
6654 if resTmp == nil {
6655 if !graphql.HasFieldError(ctx, fc) {
6656 ec.Errorf(ctx, "must not be null")
6657 }
6658 return graphql.Null
6659 }
6660 res := resTmp.([]bug.Label)
6661 fc.Result = res
6662 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6663}
6664
6665func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6666 defer func() {
6667 if r := recover(); r != nil {
6668 ec.Error(ctx, ec.Recover(ctx, r))
6669 ret = graphql.Null
6670 }
6671 }()
6672 fc := &graphql.FieldContext{
6673 Object: "LabelChangeOperation",
6674 Field: field,
6675 Args: nil,
6676 IsMethod: false,
6677 }
6678
6679 ctx = graphql.WithFieldContext(ctx, fc)
6680 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6681 ctx = rctx // use context from middleware stack in children
6682 return obj.Removed, nil
6683 })
6684 if err != nil {
6685 ec.Error(ctx, err)
6686 return graphql.Null
6687 }
6688 if resTmp == nil {
6689 if !graphql.HasFieldError(ctx, fc) {
6690 ec.Errorf(ctx, "must not be null")
6691 }
6692 return graphql.Null
6693 }
6694 res := resTmp.([]bug.Label)
6695 fc.Result = res
6696 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6697}
6698
6699func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6700 defer func() {
6701 if r := recover(); r != nil {
6702 ec.Error(ctx, ec.Recover(ctx, r))
6703 ret = graphql.Null
6704 }
6705 }()
6706 fc := &graphql.FieldContext{
6707 Object: "LabelChangeResult",
6708 Field: field,
6709 Args: nil,
6710 IsMethod: false,
6711 }
6712
6713 ctx = graphql.WithFieldContext(ctx, fc)
6714 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6715 ctx = rctx // use context from middleware stack in children
6716 return obj.Label, nil
6717 })
6718 if err != nil {
6719 ec.Error(ctx, err)
6720 return graphql.Null
6721 }
6722 if resTmp == nil {
6723 if !graphql.HasFieldError(ctx, fc) {
6724 ec.Errorf(ctx, "must not be null")
6725 }
6726 return graphql.Null
6727 }
6728 res := resTmp.(bug.Label)
6729 fc.Result = res
6730 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
6731}
6732
6733func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6734 defer func() {
6735 if r := recover(); r != nil {
6736 ec.Error(ctx, ec.Recover(ctx, r))
6737 ret = graphql.Null
6738 }
6739 }()
6740 fc := &graphql.FieldContext{
6741 Object: "LabelChangeResult",
6742 Field: field,
6743 Args: nil,
6744 IsMethod: true,
6745 }
6746
6747 ctx = graphql.WithFieldContext(ctx, fc)
6748 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6749 ctx = rctx // use context from middleware stack in children
6750 return ec.resolvers.LabelChangeResult().Status(rctx, obj)
6751 })
6752 if err != nil {
6753 ec.Error(ctx, err)
6754 return graphql.Null
6755 }
6756 if resTmp == nil {
6757 if !graphql.HasFieldError(ctx, fc) {
6758 ec.Errorf(ctx, "must not be null")
6759 }
6760 return graphql.Null
6761 }
6762 res := resTmp.(models.LabelChangeStatus)
6763 fc.Result = res
6764 return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
6765}
6766
6767func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6768 defer func() {
6769 if r := recover(); r != nil {
6770 ec.Error(ctx, ec.Recover(ctx, r))
6771 ret = graphql.Null
6772 }
6773 }()
6774 fc := &graphql.FieldContext{
6775 Object: "LabelChangeTimelineItem",
6776 Field: field,
6777 Args: nil,
6778 IsMethod: true,
6779 }
6780
6781 ctx = graphql.WithFieldContext(ctx, fc)
6782 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6783 ctx = rctx // use context from middleware stack in children
6784 return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
6785 })
6786 if err != nil {
6787 ec.Error(ctx, err)
6788 return graphql.Null
6789 }
6790 if resTmp == nil {
6791 if !graphql.HasFieldError(ctx, fc) {
6792 ec.Errorf(ctx, "must not be null")
6793 }
6794 return graphql.Null
6795 }
6796 res := resTmp.(string)
6797 fc.Result = res
6798 return ec.marshalNString2string(ctx, field.Selections, res)
6799}
6800
6801func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6802 defer func() {
6803 if r := recover(); r != nil {
6804 ec.Error(ctx, ec.Recover(ctx, r))
6805 ret = graphql.Null
6806 }
6807 }()
6808 fc := &graphql.FieldContext{
6809 Object: "LabelChangeTimelineItem",
6810 Field: field,
6811 Args: nil,
6812 IsMethod: true,
6813 }
6814
6815 ctx = graphql.WithFieldContext(ctx, fc)
6816 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6817 ctx = rctx // use context from middleware stack in children
6818 return ec.resolvers.LabelChangeTimelineItem().Author(rctx, obj)
6819 })
6820 if err != nil {
6821 ec.Error(ctx, err)
6822 return graphql.Null
6823 }
6824 if resTmp == nil {
6825 if !graphql.HasFieldError(ctx, fc) {
6826 ec.Errorf(ctx, "must not be null")
6827 }
6828 return graphql.Null
6829 }
6830 res := resTmp.(models.IdentityWrapper)
6831 fc.Result = res
6832 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6833}
6834
6835func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6836 defer func() {
6837 if r := recover(); r != nil {
6838 ec.Error(ctx, ec.Recover(ctx, r))
6839 ret = graphql.Null
6840 }
6841 }()
6842 fc := &graphql.FieldContext{
6843 Object: "LabelChangeTimelineItem",
6844 Field: field,
6845 Args: nil,
6846 IsMethod: true,
6847 }
6848
6849 ctx = graphql.WithFieldContext(ctx, fc)
6850 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6851 ctx = rctx // use context from middleware stack in children
6852 return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
6853 })
6854 if err != nil {
6855 ec.Error(ctx, err)
6856 return graphql.Null
6857 }
6858 if resTmp == nil {
6859 if !graphql.HasFieldError(ctx, fc) {
6860 ec.Errorf(ctx, "must not be null")
6861 }
6862 return graphql.Null
6863 }
6864 res := resTmp.(*time.Time)
6865 fc.Result = res
6866 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6867}
6868
6869func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6870 defer func() {
6871 if r := recover(); r != nil {
6872 ec.Error(ctx, ec.Recover(ctx, r))
6873 ret = graphql.Null
6874 }
6875 }()
6876 fc := &graphql.FieldContext{
6877 Object: "LabelChangeTimelineItem",
6878 Field: field,
6879 Args: nil,
6880 IsMethod: false,
6881 }
6882
6883 ctx = graphql.WithFieldContext(ctx, fc)
6884 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6885 ctx = rctx // use context from middleware stack in children
6886 return obj.Added, nil
6887 })
6888 if err != nil {
6889 ec.Error(ctx, err)
6890 return graphql.Null
6891 }
6892 if resTmp == nil {
6893 if !graphql.HasFieldError(ctx, fc) {
6894 ec.Errorf(ctx, "must not be null")
6895 }
6896 return graphql.Null
6897 }
6898 res := resTmp.([]bug.Label)
6899 fc.Result = res
6900 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6901}
6902
6903func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6904 defer func() {
6905 if r := recover(); r != nil {
6906 ec.Error(ctx, ec.Recover(ctx, r))
6907 ret = graphql.Null
6908 }
6909 }()
6910 fc := &graphql.FieldContext{
6911 Object: "LabelChangeTimelineItem",
6912 Field: field,
6913 Args: nil,
6914 IsMethod: false,
6915 }
6916
6917 ctx = graphql.WithFieldContext(ctx, fc)
6918 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6919 ctx = rctx // use context from middleware stack in children
6920 return obj.Removed, nil
6921 })
6922 if err != nil {
6923 ec.Error(ctx, err)
6924 return graphql.Null
6925 }
6926 if resTmp == nil {
6927 if !graphql.HasFieldError(ctx, fc) {
6928 ec.Errorf(ctx, "must not be null")
6929 }
6930 return graphql.Null
6931 }
6932 res := resTmp.([]bug.Label)
6933 fc.Result = res
6934 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6935}
6936
6937func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
6938 defer func() {
6939 if r := recover(); r != nil {
6940 ec.Error(ctx, ec.Recover(ctx, r))
6941 ret = graphql.Null
6942 }
6943 }()
6944 fc := &graphql.FieldContext{
6945 Object: "LabelConnection",
6946 Field: field,
6947 Args: nil,
6948 IsMethod: false,
6949 }
6950
6951 ctx = graphql.WithFieldContext(ctx, fc)
6952 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6953 ctx = rctx // use context from middleware stack in children
6954 return obj.Edges, nil
6955 })
6956 if err != nil {
6957 ec.Error(ctx, err)
6958 return graphql.Null
6959 }
6960 if resTmp == nil {
6961 if !graphql.HasFieldError(ctx, fc) {
6962 ec.Errorf(ctx, "must not be null")
6963 }
6964 return graphql.Null
6965 }
6966 res := resTmp.([]*models.LabelEdge)
6967 fc.Result = res
6968 return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx, field.Selections, res)
6969}
6970
6971func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
6972 defer func() {
6973 if r := recover(); r != nil {
6974 ec.Error(ctx, ec.Recover(ctx, r))
6975 ret = graphql.Null
6976 }
6977 }()
6978 fc := &graphql.FieldContext{
6979 Object: "LabelConnection",
6980 Field: field,
6981 Args: nil,
6982 IsMethod: false,
6983 }
6984
6985 ctx = graphql.WithFieldContext(ctx, fc)
6986 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6987 ctx = rctx // use context from middleware stack in children
6988 return obj.Nodes, nil
6989 })
6990 if err != nil {
6991 ec.Error(ctx, err)
6992 return graphql.Null
6993 }
6994 if resTmp == nil {
6995 if !graphql.HasFieldError(ctx, fc) {
6996 ec.Errorf(ctx, "must not be null")
6997 }
6998 return graphql.Null
6999 }
7000 res := resTmp.([]bug.Label)
7001 fc.Result = res
7002 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
7003}
7004
7005func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7006 defer func() {
7007 if r := recover(); r != nil {
7008 ec.Error(ctx, ec.Recover(ctx, r))
7009 ret = graphql.Null
7010 }
7011 }()
7012 fc := &graphql.FieldContext{
7013 Object: "LabelConnection",
7014 Field: field,
7015 Args: nil,
7016 IsMethod: false,
7017 }
7018
7019 ctx = graphql.WithFieldContext(ctx, fc)
7020 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7021 ctx = rctx // use context from middleware stack in children
7022 return obj.PageInfo, nil
7023 })
7024 if err != nil {
7025 ec.Error(ctx, err)
7026 return graphql.Null
7027 }
7028 if resTmp == nil {
7029 if !graphql.HasFieldError(ctx, fc) {
7030 ec.Errorf(ctx, "must not be null")
7031 }
7032 return graphql.Null
7033 }
7034 res := resTmp.(*models.PageInfo)
7035 fc.Result = res
7036 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
7037}
7038
7039func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7040 defer func() {
7041 if r := recover(); r != nil {
7042 ec.Error(ctx, ec.Recover(ctx, r))
7043 ret = graphql.Null
7044 }
7045 }()
7046 fc := &graphql.FieldContext{
7047 Object: "LabelConnection",
7048 Field: field,
7049 Args: nil,
7050 IsMethod: false,
7051 }
7052
7053 ctx = graphql.WithFieldContext(ctx, fc)
7054 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7055 ctx = rctx // use context from middleware stack in children
7056 return obj.TotalCount, nil
7057 })
7058 if err != nil {
7059 ec.Error(ctx, err)
7060 return graphql.Null
7061 }
7062 if resTmp == nil {
7063 if !graphql.HasFieldError(ctx, fc) {
7064 ec.Errorf(ctx, "must not be null")
7065 }
7066 return graphql.Null
7067 }
7068 res := resTmp.(int)
7069 fc.Result = res
7070 return ec.marshalNInt2int(ctx, field.Selections, res)
7071}
7072
7073func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
7074 defer func() {
7075 if r := recover(); r != nil {
7076 ec.Error(ctx, ec.Recover(ctx, r))
7077 ret = graphql.Null
7078 }
7079 }()
7080 fc := &graphql.FieldContext{
7081 Object: "LabelEdge",
7082 Field: field,
7083 Args: nil,
7084 IsMethod: false,
7085 }
7086
7087 ctx = graphql.WithFieldContext(ctx, fc)
7088 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7089 ctx = rctx // use context from middleware stack in children
7090 return obj.Cursor, nil
7091 })
7092 if err != nil {
7093 ec.Error(ctx, err)
7094 return graphql.Null
7095 }
7096 if resTmp == nil {
7097 if !graphql.HasFieldError(ctx, fc) {
7098 ec.Errorf(ctx, "must not be null")
7099 }
7100 return graphql.Null
7101 }
7102 res := resTmp.(string)
7103 fc.Result = res
7104 return ec.marshalNString2string(ctx, field.Selections, res)
7105}
7106
7107func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
7108 defer func() {
7109 if r := recover(); r != nil {
7110 ec.Error(ctx, ec.Recover(ctx, r))
7111 ret = graphql.Null
7112 }
7113 }()
7114 fc := &graphql.FieldContext{
7115 Object: "LabelEdge",
7116 Field: field,
7117 Args: nil,
7118 IsMethod: false,
7119 }
7120
7121 ctx = graphql.WithFieldContext(ctx, fc)
7122 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7123 ctx = rctx // use context from middleware stack in children
7124 return obj.Node, nil
7125 })
7126 if err != nil {
7127 ec.Error(ctx, err)
7128 return graphql.Null
7129 }
7130 if resTmp == nil {
7131 if !graphql.HasFieldError(ctx, fc) {
7132 ec.Errorf(ctx, "must not be null")
7133 }
7134 return graphql.Null
7135 }
7136 res := resTmp.(bug.Label)
7137 fc.Result = res
7138 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
7139}
7140
7141func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7142 defer func() {
7143 if r := recover(); r != nil {
7144 ec.Error(ctx, ec.Recover(ctx, r))
7145 ret = graphql.Null
7146 }
7147 }()
7148 fc := &graphql.FieldContext{
7149 Object: "Mutation",
7150 Field: field,
7151 Args: nil,
7152 IsMethod: true,
7153 }
7154
7155 ctx = graphql.WithFieldContext(ctx, fc)
7156 rawArgs := field.ArgumentMap(ec.Variables)
7157 args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
7158 if err != nil {
7159 ec.Error(ctx, err)
7160 return graphql.Null
7161 }
7162 fc.Args = args
7163 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7164 ctx = rctx // use context from middleware stack in children
7165 return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
7166 })
7167 if err != nil {
7168 ec.Error(ctx, err)
7169 return graphql.Null
7170 }
7171 if resTmp == nil {
7172 if !graphql.HasFieldError(ctx, fc) {
7173 ec.Errorf(ctx, "must not be null")
7174 }
7175 return graphql.Null
7176 }
7177 res := resTmp.(*models.NewBugPayload)
7178 fc.Result = res
7179 return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
7180}
7181
7182func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7183 defer func() {
7184 if r := recover(); r != nil {
7185 ec.Error(ctx, ec.Recover(ctx, r))
7186 ret = graphql.Null
7187 }
7188 }()
7189 fc := &graphql.FieldContext{
7190 Object: "Mutation",
7191 Field: field,
7192 Args: nil,
7193 IsMethod: true,
7194 }
7195
7196 ctx = graphql.WithFieldContext(ctx, fc)
7197 rawArgs := field.ArgumentMap(ec.Variables)
7198 args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
7199 if err != nil {
7200 ec.Error(ctx, err)
7201 return graphql.Null
7202 }
7203 fc.Args = args
7204 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7205 ctx = rctx // use context from middleware stack in children
7206 return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
7207 })
7208 if err != nil {
7209 ec.Error(ctx, err)
7210 return graphql.Null
7211 }
7212 if resTmp == nil {
7213 if !graphql.HasFieldError(ctx, fc) {
7214 ec.Errorf(ctx, "must not be null")
7215 }
7216 return graphql.Null
7217 }
7218 res := resTmp.(*models.AddCommentPayload)
7219 fc.Result = res
7220 return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
7221}
7222
7223func (ec *executionContext) _Mutation_addCommentAndClose(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7224 defer func() {
7225 if r := recover(); r != nil {
7226 ec.Error(ctx, ec.Recover(ctx, r))
7227 ret = graphql.Null
7228 }
7229 }()
7230 fc := &graphql.FieldContext{
7231 Object: "Mutation",
7232 Field: field,
7233 Args: nil,
7234 IsMethod: true,
7235 }
7236
7237 ctx = graphql.WithFieldContext(ctx, fc)
7238 rawArgs := field.ArgumentMap(ec.Variables)
7239 args, err := ec.field_Mutation_addCommentAndClose_args(ctx, rawArgs)
7240 if err != nil {
7241 ec.Error(ctx, err)
7242 return graphql.Null
7243 }
7244 fc.Args = args
7245 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7246 ctx = rctx // use context from middleware stack in children
7247 return ec.resolvers.Mutation().AddCommentAndClose(rctx, args["input"].(models.AddCommentAndCloseBugInput))
7248 })
7249 if err != nil {
7250 ec.Error(ctx, err)
7251 return graphql.Null
7252 }
7253 if resTmp == nil {
7254 if !graphql.HasFieldError(ctx, fc) {
7255 ec.Errorf(ctx, "must not be null")
7256 }
7257 return graphql.Null
7258 }
7259 res := resTmp.(*models.AddCommentAndCloseBugPayload)
7260 fc.Result = res
7261 return ec.marshalNAddCommentAndCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx, field.Selections, res)
7262}
7263
7264func (ec *executionContext) _Mutation_editComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7265 defer func() {
7266 if r := recover(); r != nil {
7267 ec.Error(ctx, ec.Recover(ctx, r))
7268 ret = graphql.Null
7269 }
7270 }()
7271 fc := &graphql.FieldContext{
7272 Object: "Mutation",
7273 Field: field,
7274 Args: nil,
7275 IsMethod: true,
7276 }
7277
7278 ctx = graphql.WithFieldContext(ctx, fc)
7279 rawArgs := field.ArgumentMap(ec.Variables)
7280 args, err := ec.field_Mutation_editComment_args(ctx, rawArgs)
7281 if err != nil {
7282 ec.Error(ctx, err)
7283 return graphql.Null
7284 }
7285 fc.Args = args
7286 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7287 ctx = rctx // use context from middleware stack in children
7288 return ec.resolvers.Mutation().EditComment(rctx, args["input"].(models.EditCommentInput))
7289 })
7290 if err != nil {
7291 ec.Error(ctx, err)
7292 return graphql.Null
7293 }
7294 if resTmp == nil {
7295 if !graphql.HasFieldError(ctx, fc) {
7296 ec.Errorf(ctx, "must not be null")
7297 }
7298 return graphql.Null
7299 }
7300 res := resTmp.(*models.EditCommentPayload)
7301 fc.Result = res
7302 return ec.marshalNEditCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx, field.Selections, res)
7303}
7304
7305func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7306 defer func() {
7307 if r := recover(); r != nil {
7308 ec.Error(ctx, ec.Recover(ctx, r))
7309 ret = graphql.Null
7310 }
7311 }()
7312 fc := &graphql.FieldContext{
7313 Object: "Mutation",
7314 Field: field,
7315 Args: nil,
7316 IsMethod: true,
7317 }
7318
7319 ctx = graphql.WithFieldContext(ctx, fc)
7320 rawArgs := field.ArgumentMap(ec.Variables)
7321 args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
7322 if err != nil {
7323 ec.Error(ctx, err)
7324 return graphql.Null
7325 }
7326 fc.Args = args
7327 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7328 ctx = rctx // use context from middleware stack in children
7329 return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
7330 })
7331 if err != nil {
7332 ec.Error(ctx, err)
7333 return graphql.Null
7334 }
7335 if resTmp == nil {
7336 if !graphql.HasFieldError(ctx, fc) {
7337 ec.Errorf(ctx, "must not be null")
7338 }
7339 return graphql.Null
7340 }
7341 res := resTmp.(*models.ChangeLabelPayload)
7342 fc.Result = res
7343 return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
7344}
7345
7346func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7347 defer func() {
7348 if r := recover(); r != nil {
7349 ec.Error(ctx, ec.Recover(ctx, r))
7350 ret = graphql.Null
7351 }
7352 }()
7353 fc := &graphql.FieldContext{
7354 Object: "Mutation",
7355 Field: field,
7356 Args: nil,
7357 IsMethod: true,
7358 }
7359
7360 ctx = graphql.WithFieldContext(ctx, fc)
7361 rawArgs := field.ArgumentMap(ec.Variables)
7362 args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
7363 if err != nil {
7364 ec.Error(ctx, err)
7365 return graphql.Null
7366 }
7367 fc.Args = args
7368 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7369 ctx = rctx // use context from middleware stack in children
7370 return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
7371 })
7372 if err != nil {
7373 ec.Error(ctx, err)
7374 return graphql.Null
7375 }
7376 if resTmp == nil {
7377 if !graphql.HasFieldError(ctx, fc) {
7378 ec.Errorf(ctx, "must not be null")
7379 }
7380 return graphql.Null
7381 }
7382 res := resTmp.(*models.OpenBugPayload)
7383 fc.Result = res
7384 return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
7385}
7386
7387func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7388 defer func() {
7389 if r := recover(); r != nil {
7390 ec.Error(ctx, ec.Recover(ctx, r))
7391 ret = graphql.Null
7392 }
7393 }()
7394 fc := &graphql.FieldContext{
7395 Object: "Mutation",
7396 Field: field,
7397 Args: nil,
7398 IsMethod: true,
7399 }
7400
7401 ctx = graphql.WithFieldContext(ctx, fc)
7402 rawArgs := field.ArgumentMap(ec.Variables)
7403 args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
7404 if err != nil {
7405 ec.Error(ctx, err)
7406 return graphql.Null
7407 }
7408 fc.Args = args
7409 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7410 ctx = rctx // use context from middleware stack in children
7411 return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
7412 })
7413 if err != nil {
7414 ec.Error(ctx, err)
7415 return graphql.Null
7416 }
7417 if resTmp == nil {
7418 if !graphql.HasFieldError(ctx, fc) {
7419 ec.Errorf(ctx, "must not be null")
7420 }
7421 return graphql.Null
7422 }
7423 res := resTmp.(*models.CloseBugPayload)
7424 fc.Result = res
7425 return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
7426}
7427
7428func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7429 defer func() {
7430 if r := recover(); r != nil {
7431 ec.Error(ctx, ec.Recover(ctx, r))
7432 ret = graphql.Null
7433 }
7434 }()
7435 fc := &graphql.FieldContext{
7436 Object: "Mutation",
7437 Field: field,
7438 Args: nil,
7439 IsMethod: true,
7440 }
7441
7442 ctx = graphql.WithFieldContext(ctx, fc)
7443 rawArgs := field.ArgumentMap(ec.Variables)
7444 args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
7445 if err != nil {
7446 ec.Error(ctx, err)
7447 return graphql.Null
7448 }
7449 fc.Args = args
7450 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7451 ctx = rctx // use context from middleware stack in children
7452 return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
7453 })
7454 if err != nil {
7455 ec.Error(ctx, err)
7456 return graphql.Null
7457 }
7458 if resTmp == nil {
7459 if !graphql.HasFieldError(ctx, fc) {
7460 ec.Errorf(ctx, "must not be null")
7461 }
7462 return graphql.Null
7463 }
7464 res := resTmp.(*models.SetTitlePayload)
7465 fc.Result = res
7466 return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
7467}
7468
7469func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7470 defer func() {
7471 if r := recover(); r != nil {
7472 ec.Error(ctx, ec.Recover(ctx, r))
7473 ret = graphql.Null
7474 }
7475 }()
7476 fc := &graphql.FieldContext{
7477 Object: "NewBugPayload",
7478 Field: field,
7479 Args: nil,
7480 IsMethod: false,
7481 }
7482
7483 ctx = graphql.WithFieldContext(ctx, fc)
7484 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7485 ctx = rctx // use context from middleware stack in children
7486 return obj.ClientMutationID, nil
7487 })
7488 if err != nil {
7489 ec.Error(ctx, err)
7490 return graphql.Null
7491 }
7492 if resTmp == nil {
7493 return graphql.Null
7494 }
7495 res := resTmp.(*string)
7496 fc.Result = res
7497 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7498}
7499
7500func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7501 defer func() {
7502 if r := recover(); r != nil {
7503 ec.Error(ctx, ec.Recover(ctx, r))
7504 ret = graphql.Null
7505 }
7506 }()
7507 fc := &graphql.FieldContext{
7508 Object: "NewBugPayload",
7509 Field: field,
7510 Args: nil,
7511 IsMethod: false,
7512 }
7513
7514 ctx = graphql.WithFieldContext(ctx, fc)
7515 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7516 ctx = rctx // use context from middleware stack in children
7517 return obj.Bug, nil
7518 })
7519 if err != nil {
7520 ec.Error(ctx, err)
7521 return graphql.Null
7522 }
7523 if resTmp == nil {
7524 if !graphql.HasFieldError(ctx, fc) {
7525 ec.Errorf(ctx, "must not be null")
7526 }
7527 return graphql.Null
7528 }
7529 res := resTmp.(models.BugWrapper)
7530 fc.Result = res
7531 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
7532}
7533
7534func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7535 defer func() {
7536 if r := recover(); r != nil {
7537 ec.Error(ctx, ec.Recover(ctx, r))
7538 ret = graphql.Null
7539 }
7540 }()
7541 fc := &graphql.FieldContext{
7542 Object: "NewBugPayload",
7543 Field: field,
7544 Args: nil,
7545 IsMethod: false,
7546 }
7547
7548 ctx = graphql.WithFieldContext(ctx, fc)
7549 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7550 ctx = rctx // use context from middleware stack in children
7551 return obj.Operation, nil
7552 })
7553 if err != nil {
7554 ec.Error(ctx, err)
7555 return graphql.Null
7556 }
7557 if resTmp == nil {
7558 if !graphql.HasFieldError(ctx, fc) {
7559 ec.Errorf(ctx, "must not be null")
7560 }
7561 return graphql.Null
7562 }
7563 res := resTmp.(*bug.CreateOperation)
7564 fc.Result = res
7565 return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
7566}
7567
7568func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7569 defer func() {
7570 if r := recover(); r != nil {
7571 ec.Error(ctx, ec.Recover(ctx, r))
7572 ret = graphql.Null
7573 }
7574 }()
7575 fc := &graphql.FieldContext{
7576 Object: "OpenBugPayload",
7577 Field: field,
7578 Args: nil,
7579 IsMethod: false,
7580 }
7581
7582 ctx = graphql.WithFieldContext(ctx, fc)
7583 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7584 ctx = rctx // use context from middleware stack in children
7585 return obj.ClientMutationID, nil
7586 })
7587 if err != nil {
7588 ec.Error(ctx, err)
7589 return graphql.Null
7590 }
7591 if resTmp == nil {
7592 return graphql.Null
7593 }
7594 res := resTmp.(*string)
7595 fc.Result = res
7596 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7597}
7598
7599func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7600 defer func() {
7601 if r := recover(); r != nil {
7602 ec.Error(ctx, ec.Recover(ctx, r))
7603 ret = graphql.Null
7604 }
7605 }()
7606 fc := &graphql.FieldContext{
7607 Object: "OpenBugPayload",
7608 Field: field,
7609 Args: nil,
7610 IsMethod: false,
7611 }
7612
7613 ctx = graphql.WithFieldContext(ctx, fc)
7614 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7615 ctx = rctx // use context from middleware stack in children
7616 return obj.Bug, nil
7617 })
7618 if err != nil {
7619 ec.Error(ctx, err)
7620 return graphql.Null
7621 }
7622 if resTmp == nil {
7623 if !graphql.HasFieldError(ctx, fc) {
7624 ec.Errorf(ctx, "must not be null")
7625 }
7626 return graphql.Null
7627 }
7628 res := resTmp.(models.BugWrapper)
7629 fc.Result = res
7630 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
7631}
7632
7633func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7634 defer func() {
7635 if r := recover(); r != nil {
7636 ec.Error(ctx, ec.Recover(ctx, r))
7637 ret = graphql.Null
7638 }
7639 }()
7640 fc := &graphql.FieldContext{
7641 Object: "OpenBugPayload",
7642 Field: field,
7643 Args: nil,
7644 IsMethod: false,
7645 }
7646
7647 ctx = graphql.WithFieldContext(ctx, fc)
7648 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7649 ctx = rctx // use context from middleware stack in children
7650 return obj.Operation, nil
7651 })
7652 if err != nil {
7653 ec.Error(ctx, err)
7654 return graphql.Null
7655 }
7656 if resTmp == nil {
7657 if !graphql.HasFieldError(ctx, fc) {
7658 ec.Errorf(ctx, "must not be null")
7659 }
7660 return graphql.Null
7661 }
7662 res := resTmp.(*bug.SetStatusOperation)
7663 fc.Result = res
7664 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
7665}
7666
7667func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7668 defer func() {
7669 if r := recover(); r != nil {
7670 ec.Error(ctx, ec.Recover(ctx, r))
7671 ret = graphql.Null
7672 }
7673 }()
7674 fc := &graphql.FieldContext{
7675 Object: "OperationConnection",
7676 Field: field,
7677 Args: nil,
7678 IsMethod: false,
7679 }
7680
7681 ctx = graphql.WithFieldContext(ctx, fc)
7682 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7683 ctx = rctx // use context from middleware stack in children
7684 return obj.Edges, nil
7685 })
7686 if err != nil {
7687 ec.Error(ctx, err)
7688 return graphql.Null
7689 }
7690 if resTmp == nil {
7691 if !graphql.HasFieldError(ctx, fc) {
7692 ec.Errorf(ctx, "must not be null")
7693 }
7694 return graphql.Null
7695 }
7696 res := resTmp.([]*models.OperationEdge)
7697 fc.Result = res
7698 return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
7699}
7700
7701func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7702 defer func() {
7703 if r := recover(); r != nil {
7704 ec.Error(ctx, ec.Recover(ctx, r))
7705 ret = graphql.Null
7706 }
7707 }()
7708 fc := &graphql.FieldContext{
7709 Object: "OperationConnection",
7710 Field: field,
7711 Args: nil,
7712 IsMethod: false,
7713 }
7714
7715 ctx = graphql.WithFieldContext(ctx, fc)
7716 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7717 ctx = rctx // use context from middleware stack in children
7718 return obj.Nodes, nil
7719 })
7720 if err != nil {
7721 ec.Error(ctx, err)
7722 return graphql.Null
7723 }
7724 if resTmp == nil {
7725 if !graphql.HasFieldError(ctx, fc) {
7726 ec.Errorf(ctx, "must not be null")
7727 }
7728 return graphql.Null
7729 }
7730 res := resTmp.([]bug.Operation)
7731 fc.Result = res
7732 return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx, field.Selections, res)
7733}
7734
7735func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7736 defer func() {
7737 if r := recover(); r != nil {
7738 ec.Error(ctx, ec.Recover(ctx, r))
7739 ret = graphql.Null
7740 }
7741 }()
7742 fc := &graphql.FieldContext{
7743 Object: "OperationConnection",
7744 Field: field,
7745 Args: nil,
7746 IsMethod: false,
7747 }
7748
7749 ctx = graphql.WithFieldContext(ctx, fc)
7750 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7751 ctx = rctx // use context from middleware stack in children
7752 return obj.PageInfo, nil
7753 })
7754 if err != nil {
7755 ec.Error(ctx, err)
7756 return graphql.Null
7757 }
7758 if resTmp == nil {
7759 if !graphql.HasFieldError(ctx, fc) {
7760 ec.Errorf(ctx, "must not be null")
7761 }
7762 return graphql.Null
7763 }
7764 res := resTmp.(*models.PageInfo)
7765 fc.Result = res
7766 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
7767}
7768
7769func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7770 defer func() {
7771 if r := recover(); r != nil {
7772 ec.Error(ctx, ec.Recover(ctx, r))
7773 ret = graphql.Null
7774 }
7775 }()
7776 fc := &graphql.FieldContext{
7777 Object: "OperationConnection",
7778 Field: field,
7779 Args: nil,
7780 IsMethod: false,
7781 }
7782
7783 ctx = graphql.WithFieldContext(ctx, fc)
7784 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7785 ctx = rctx // use context from middleware stack in children
7786 return obj.TotalCount, nil
7787 })
7788 if err != nil {
7789 ec.Error(ctx, err)
7790 return graphql.Null
7791 }
7792 if resTmp == nil {
7793 if !graphql.HasFieldError(ctx, fc) {
7794 ec.Errorf(ctx, "must not be null")
7795 }
7796 return graphql.Null
7797 }
7798 res := resTmp.(int)
7799 fc.Result = res
7800 return ec.marshalNInt2int(ctx, field.Selections, res)
7801}
7802
7803func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
7804 defer func() {
7805 if r := recover(); r != nil {
7806 ec.Error(ctx, ec.Recover(ctx, r))
7807 ret = graphql.Null
7808 }
7809 }()
7810 fc := &graphql.FieldContext{
7811 Object: "OperationEdge",
7812 Field: field,
7813 Args: nil,
7814 IsMethod: false,
7815 }
7816
7817 ctx = graphql.WithFieldContext(ctx, fc)
7818 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7819 ctx = rctx // use context from middleware stack in children
7820 return obj.Cursor, nil
7821 })
7822 if err != nil {
7823 ec.Error(ctx, err)
7824 return graphql.Null
7825 }
7826 if resTmp == nil {
7827 if !graphql.HasFieldError(ctx, fc) {
7828 ec.Errorf(ctx, "must not be null")
7829 }
7830 return graphql.Null
7831 }
7832 res := resTmp.(string)
7833 fc.Result = res
7834 return ec.marshalNString2string(ctx, field.Selections, res)
7835}
7836
7837func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
7838 defer func() {
7839 if r := recover(); r != nil {
7840 ec.Error(ctx, ec.Recover(ctx, r))
7841 ret = graphql.Null
7842 }
7843 }()
7844 fc := &graphql.FieldContext{
7845 Object: "OperationEdge",
7846 Field: field,
7847 Args: nil,
7848 IsMethod: false,
7849 }
7850
7851 ctx = graphql.WithFieldContext(ctx, fc)
7852 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7853 ctx = rctx // use context from middleware stack in children
7854 return obj.Node, nil
7855 })
7856 if err != nil {
7857 ec.Error(ctx, err)
7858 return graphql.Null
7859 }
7860 if resTmp == nil {
7861 if !graphql.HasFieldError(ctx, fc) {
7862 ec.Errorf(ctx, "must not be null")
7863 }
7864 return graphql.Null
7865 }
7866 res := resTmp.(bug.Operation)
7867 fc.Result = res
7868 return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
7869}
7870
7871func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7872 defer func() {
7873 if r := recover(); r != nil {
7874 ec.Error(ctx, ec.Recover(ctx, r))
7875 ret = graphql.Null
7876 }
7877 }()
7878 fc := &graphql.FieldContext{
7879 Object: "PageInfo",
7880 Field: field,
7881 Args: nil,
7882 IsMethod: false,
7883 }
7884
7885 ctx = graphql.WithFieldContext(ctx, fc)
7886 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7887 ctx = rctx // use context from middleware stack in children
7888 return obj.HasNextPage, nil
7889 })
7890 if err != nil {
7891 ec.Error(ctx, err)
7892 return graphql.Null
7893 }
7894 if resTmp == nil {
7895 if !graphql.HasFieldError(ctx, fc) {
7896 ec.Errorf(ctx, "must not be null")
7897 }
7898 return graphql.Null
7899 }
7900 res := resTmp.(bool)
7901 fc.Result = res
7902 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
7903}
7904
7905func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7906 defer func() {
7907 if r := recover(); r != nil {
7908 ec.Error(ctx, ec.Recover(ctx, r))
7909 ret = graphql.Null
7910 }
7911 }()
7912 fc := &graphql.FieldContext{
7913 Object: "PageInfo",
7914 Field: field,
7915 Args: nil,
7916 IsMethod: false,
7917 }
7918
7919 ctx = graphql.WithFieldContext(ctx, fc)
7920 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7921 ctx = rctx // use context from middleware stack in children
7922 return obj.HasPreviousPage, nil
7923 })
7924 if err != nil {
7925 ec.Error(ctx, err)
7926 return graphql.Null
7927 }
7928 if resTmp == nil {
7929 if !graphql.HasFieldError(ctx, fc) {
7930 ec.Errorf(ctx, "must not be null")
7931 }
7932 return graphql.Null
7933 }
7934 res := resTmp.(bool)
7935 fc.Result = res
7936 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
7937}
7938
7939func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7940 defer func() {
7941 if r := recover(); r != nil {
7942 ec.Error(ctx, ec.Recover(ctx, r))
7943 ret = graphql.Null
7944 }
7945 }()
7946 fc := &graphql.FieldContext{
7947 Object: "PageInfo",
7948 Field: field,
7949 Args: nil,
7950 IsMethod: false,
7951 }
7952
7953 ctx = graphql.WithFieldContext(ctx, fc)
7954 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7955 ctx = rctx // use context from middleware stack in children
7956 return obj.StartCursor, nil
7957 })
7958 if err != nil {
7959 ec.Error(ctx, err)
7960 return graphql.Null
7961 }
7962 if resTmp == nil {
7963 if !graphql.HasFieldError(ctx, fc) {
7964 ec.Errorf(ctx, "must not be null")
7965 }
7966 return graphql.Null
7967 }
7968 res := resTmp.(string)
7969 fc.Result = res
7970 return ec.marshalNString2string(ctx, field.Selections, res)
7971}
7972
7973func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7974 defer func() {
7975 if r := recover(); r != nil {
7976 ec.Error(ctx, ec.Recover(ctx, r))
7977 ret = graphql.Null
7978 }
7979 }()
7980 fc := &graphql.FieldContext{
7981 Object: "PageInfo",
7982 Field: field,
7983 Args: nil,
7984 IsMethod: false,
7985 }
7986
7987 ctx = graphql.WithFieldContext(ctx, fc)
7988 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7989 ctx = rctx // use context from middleware stack in children
7990 return obj.EndCursor, nil
7991 })
7992 if err != nil {
7993 ec.Error(ctx, err)
7994 return graphql.Null
7995 }
7996 if resTmp == nil {
7997 if !graphql.HasFieldError(ctx, fc) {
7998 ec.Errorf(ctx, "must not be null")
7999 }
8000 return graphql.Null
8001 }
8002 res := resTmp.(string)
8003 fc.Result = res
8004 return ec.marshalNString2string(ctx, field.Selections, res)
8005}
8006
8007func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8008 defer func() {
8009 if r := recover(); r != nil {
8010 ec.Error(ctx, ec.Recover(ctx, r))
8011 ret = graphql.Null
8012 }
8013 }()
8014 fc := &graphql.FieldContext{
8015 Object: "Query",
8016 Field: field,
8017 Args: nil,
8018 IsMethod: true,
8019 }
8020
8021 ctx = graphql.WithFieldContext(ctx, fc)
8022 rawArgs := field.ArgumentMap(ec.Variables)
8023 args, err := ec.field_Query_repository_args(ctx, rawArgs)
8024 if err != nil {
8025 ec.Error(ctx, err)
8026 return graphql.Null
8027 }
8028 fc.Args = args
8029 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8030 ctx = rctx // use context from middleware stack in children
8031 return ec.resolvers.Query().Repository(rctx, args["ref"].(*string))
8032 })
8033 if err != nil {
8034 ec.Error(ctx, err)
8035 return graphql.Null
8036 }
8037 if resTmp == nil {
8038 return graphql.Null
8039 }
8040 res := resTmp.(*models.Repository)
8041 fc.Result = res
8042 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
8043}
8044
8045func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8046 defer func() {
8047 if r := recover(); r != nil {
8048 ec.Error(ctx, ec.Recover(ctx, r))
8049 ret = graphql.Null
8050 }
8051 }()
8052 fc := &graphql.FieldContext{
8053 Object: "Query",
8054 Field: field,
8055 Args: nil,
8056 IsMethod: true,
8057 }
8058
8059 ctx = graphql.WithFieldContext(ctx, fc)
8060 rawArgs := field.ArgumentMap(ec.Variables)
8061 args, err := ec.field_Query___type_args(ctx, rawArgs)
8062 if err != nil {
8063 ec.Error(ctx, err)
8064 return graphql.Null
8065 }
8066 fc.Args = args
8067 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8068 ctx = rctx // use context from middleware stack in children
8069 return ec.introspectType(args["name"].(string))
8070 })
8071 if err != nil {
8072 ec.Error(ctx, err)
8073 return graphql.Null
8074 }
8075 if resTmp == nil {
8076 return graphql.Null
8077 }
8078 res := resTmp.(*introspection.Type)
8079 fc.Result = res
8080 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
8081}
8082
8083func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8084 defer func() {
8085 if r := recover(); r != nil {
8086 ec.Error(ctx, ec.Recover(ctx, r))
8087 ret = graphql.Null
8088 }
8089 }()
8090 fc := &graphql.FieldContext{
8091 Object: "Query",
8092 Field: field,
8093 Args: nil,
8094 IsMethod: true,
8095 }
8096
8097 ctx = graphql.WithFieldContext(ctx, fc)
8098 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8099 ctx = rctx // use context from middleware stack in children
8100 return ec.introspectSchema()
8101 })
8102 if err != nil {
8103 ec.Error(ctx, err)
8104 return graphql.Null
8105 }
8106 if resTmp == nil {
8107 return graphql.Null
8108 }
8109 res := resTmp.(*introspection.Schema)
8110 fc.Result = res
8111 return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
8112}
8113
8114func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8115 defer func() {
8116 if r := recover(); r != nil {
8117 ec.Error(ctx, ec.Recover(ctx, r))
8118 ret = graphql.Null
8119 }
8120 }()
8121 fc := &graphql.FieldContext{
8122 Object: "Repository",
8123 Field: field,
8124 Args: nil,
8125 IsMethod: true,
8126 }
8127
8128 ctx = graphql.WithFieldContext(ctx, fc)
8129 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8130 ctx = rctx // use context from middleware stack in children
8131 return ec.resolvers.Repository().Name(rctx, obj)
8132 })
8133 if err != nil {
8134 ec.Error(ctx, err)
8135 return graphql.Null
8136 }
8137 if resTmp == nil {
8138 return graphql.Null
8139 }
8140 res := resTmp.(*string)
8141 fc.Result = res
8142 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
8143}
8144
8145func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8146 defer func() {
8147 if r := recover(); r != nil {
8148 ec.Error(ctx, ec.Recover(ctx, r))
8149 ret = graphql.Null
8150 }
8151 }()
8152 fc := &graphql.FieldContext{
8153 Object: "Repository",
8154 Field: field,
8155 Args: nil,
8156 IsMethod: true,
8157 }
8158
8159 ctx = graphql.WithFieldContext(ctx, fc)
8160 rawArgs := field.ArgumentMap(ec.Variables)
8161 args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
8162 if err != nil {
8163 ec.Error(ctx, err)
8164 return graphql.Null
8165 }
8166 fc.Args = args
8167 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8168 ctx = rctx // use context from middleware stack in children
8169 return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
8170 })
8171 if err != nil {
8172 ec.Error(ctx, err)
8173 return graphql.Null
8174 }
8175 if resTmp == nil {
8176 if !graphql.HasFieldError(ctx, fc) {
8177 ec.Errorf(ctx, "must not be null")
8178 }
8179 return graphql.Null
8180 }
8181 res := resTmp.(*models.BugConnection)
8182 fc.Result = res
8183 return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
8184}
8185
8186func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8187 defer func() {
8188 if r := recover(); r != nil {
8189 ec.Error(ctx, ec.Recover(ctx, r))
8190 ret = graphql.Null
8191 }
8192 }()
8193 fc := &graphql.FieldContext{
8194 Object: "Repository",
8195 Field: field,
8196 Args: nil,
8197 IsMethod: true,
8198 }
8199
8200 ctx = graphql.WithFieldContext(ctx, fc)
8201 rawArgs := field.ArgumentMap(ec.Variables)
8202 args, err := ec.field_Repository_bug_args(ctx, rawArgs)
8203 if err != nil {
8204 ec.Error(ctx, err)
8205 return graphql.Null
8206 }
8207 fc.Args = args
8208 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8209 ctx = rctx // use context from middleware stack in children
8210 return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
8211 })
8212 if err != nil {
8213 ec.Error(ctx, err)
8214 return graphql.Null
8215 }
8216 if resTmp == nil {
8217 return graphql.Null
8218 }
8219 res := resTmp.(models.BugWrapper)
8220 fc.Result = res
8221 return ec.marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
8222}
8223
8224func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8225 defer func() {
8226 if r := recover(); r != nil {
8227 ec.Error(ctx, ec.Recover(ctx, r))
8228 ret = graphql.Null
8229 }
8230 }()
8231 fc := &graphql.FieldContext{
8232 Object: "Repository",
8233 Field: field,
8234 Args: nil,
8235 IsMethod: true,
8236 }
8237
8238 ctx = graphql.WithFieldContext(ctx, fc)
8239 rawArgs := field.ArgumentMap(ec.Variables)
8240 args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
8241 if err != nil {
8242 ec.Error(ctx, err)
8243 return graphql.Null
8244 }
8245 fc.Args = args
8246 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8247 ctx = rctx // use context from middleware stack in children
8248 return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8249 })
8250 if err != nil {
8251 ec.Error(ctx, err)
8252 return graphql.Null
8253 }
8254 if resTmp == nil {
8255 if !graphql.HasFieldError(ctx, fc) {
8256 ec.Errorf(ctx, "must not be null")
8257 }
8258 return graphql.Null
8259 }
8260 res := resTmp.(*models.IdentityConnection)
8261 fc.Result = res
8262 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
8263}
8264
8265func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8266 defer func() {
8267 if r := recover(); r != nil {
8268 ec.Error(ctx, ec.Recover(ctx, r))
8269 ret = graphql.Null
8270 }
8271 }()
8272 fc := &graphql.FieldContext{
8273 Object: "Repository",
8274 Field: field,
8275 Args: nil,
8276 IsMethod: true,
8277 }
8278
8279 ctx = graphql.WithFieldContext(ctx, fc)
8280 rawArgs := field.ArgumentMap(ec.Variables)
8281 args, err := ec.field_Repository_identity_args(ctx, rawArgs)
8282 if err != nil {
8283 ec.Error(ctx, err)
8284 return graphql.Null
8285 }
8286 fc.Args = args
8287 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8288 ctx = rctx // use context from middleware stack in children
8289 return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
8290 })
8291 if err != nil {
8292 ec.Error(ctx, err)
8293 return graphql.Null
8294 }
8295 if resTmp == nil {
8296 return graphql.Null
8297 }
8298 res := resTmp.(models.IdentityWrapper)
8299 fc.Result = res
8300 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8301}
8302
8303func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8304 defer func() {
8305 if r := recover(); r != nil {
8306 ec.Error(ctx, ec.Recover(ctx, r))
8307 ret = graphql.Null
8308 }
8309 }()
8310 fc := &graphql.FieldContext{
8311 Object: "Repository",
8312 Field: field,
8313 Args: nil,
8314 IsMethod: true,
8315 }
8316
8317 ctx = graphql.WithFieldContext(ctx, fc)
8318 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8319 ctx = rctx // use context from middleware stack in children
8320 return ec.resolvers.Repository().UserIdentity(rctx, obj)
8321 })
8322 if err != nil {
8323 ec.Error(ctx, err)
8324 return graphql.Null
8325 }
8326 if resTmp == nil {
8327 return graphql.Null
8328 }
8329 res := resTmp.(models.IdentityWrapper)
8330 fc.Result = res
8331 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8332}
8333
8334func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8335 defer func() {
8336 if r := recover(); r != nil {
8337 ec.Error(ctx, ec.Recover(ctx, r))
8338 ret = graphql.Null
8339 }
8340 }()
8341 fc := &graphql.FieldContext{
8342 Object: "Repository",
8343 Field: field,
8344 Args: nil,
8345 IsMethod: true,
8346 }
8347
8348 ctx = graphql.WithFieldContext(ctx, fc)
8349 rawArgs := field.ArgumentMap(ec.Variables)
8350 args, err := ec.field_Repository_validLabels_args(ctx, rawArgs)
8351 if err != nil {
8352 ec.Error(ctx, err)
8353 return graphql.Null
8354 }
8355 fc.Args = args
8356 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8357 ctx = rctx // use context from middleware stack in children
8358 return ec.resolvers.Repository().ValidLabels(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8359 })
8360 if err != nil {
8361 ec.Error(ctx, err)
8362 return graphql.Null
8363 }
8364 if resTmp == nil {
8365 if !graphql.HasFieldError(ctx, fc) {
8366 ec.Errorf(ctx, "must not be null")
8367 }
8368 return graphql.Null
8369 }
8370 res := resTmp.(*models.LabelConnection)
8371 fc.Result = res
8372 return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
8373}
8374
8375func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8376 defer func() {
8377 if r := recover(); r != nil {
8378 ec.Error(ctx, ec.Recover(ctx, r))
8379 ret = graphql.Null
8380 }
8381 }()
8382 fc := &graphql.FieldContext{
8383 Object: "SetStatusOperation",
8384 Field: field,
8385 Args: nil,
8386 IsMethod: true,
8387 }
8388
8389 ctx = graphql.WithFieldContext(ctx, fc)
8390 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8391 ctx = rctx // use context from middleware stack in children
8392 return ec.resolvers.SetStatusOperation().ID(rctx, obj)
8393 })
8394 if err != nil {
8395 ec.Error(ctx, err)
8396 return graphql.Null
8397 }
8398 if resTmp == nil {
8399 if !graphql.HasFieldError(ctx, fc) {
8400 ec.Errorf(ctx, "must not be null")
8401 }
8402 return graphql.Null
8403 }
8404 res := resTmp.(string)
8405 fc.Result = res
8406 return ec.marshalNString2string(ctx, field.Selections, res)
8407}
8408
8409func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8410 defer func() {
8411 if r := recover(); r != nil {
8412 ec.Error(ctx, ec.Recover(ctx, r))
8413 ret = graphql.Null
8414 }
8415 }()
8416 fc := &graphql.FieldContext{
8417 Object: "SetStatusOperation",
8418 Field: field,
8419 Args: nil,
8420 IsMethod: true,
8421 }
8422
8423 ctx = graphql.WithFieldContext(ctx, fc)
8424 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8425 ctx = rctx // use context from middleware stack in children
8426 return ec.resolvers.SetStatusOperation().Author(rctx, obj)
8427 })
8428 if err != nil {
8429 ec.Error(ctx, err)
8430 return graphql.Null
8431 }
8432 if resTmp == nil {
8433 if !graphql.HasFieldError(ctx, fc) {
8434 ec.Errorf(ctx, "must not be null")
8435 }
8436 return graphql.Null
8437 }
8438 res := resTmp.(models.IdentityWrapper)
8439 fc.Result = res
8440 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8441}
8442
8443func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8444 defer func() {
8445 if r := recover(); r != nil {
8446 ec.Error(ctx, ec.Recover(ctx, r))
8447 ret = graphql.Null
8448 }
8449 }()
8450 fc := &graphql.FieldContext{
8451 Object: "SetStatusOperation",
8452 Field: field,
8453 Args: nil,
8454 IsMethod: true,
8455 }
8456
8457 ctx = graphql.WithFieldContext(ctx, fc)
8458 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8459 ctx = rctx // use context from middleware stack in children
8460 return ec.resolvers.SetStatusOperation().Date(rctx, obj)
8461 })
8462 if err != nil {
8463 ec.Error(ctx, err)
8464 return graphql.Null
8465 }
8466 if resTmp == nil {
8467 if !graphql.HasFieldError(ctx, fc) {
8468 ec.Errorf(ctx, "must not be null")
8469 }
8470 return graphql.Null
8471 }
8472 res := resTmp.(*time.Time)
8473 fc.Result = res
8474 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8475}
8476
8477func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8478 defer func() {
8479 if r := recover(); r != nil {
8480 ec.Error(ctx, ec.Recover(ctx, r))
8481 ret = graphql.Null
8482 }
8483 }()
8484 fc := &graphql.FieldContext{
8485 Object: "SetStatusOperation",
8486 Field: field,
8487 Args: nil,
8488 IsMethod: true,
8489 }
8490
8491 ctx = graphql.WithFieldContext(ctx, fc)
8492 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8493 ctx = rctx // use context from middleware stack in children
8494 return ec.resolvers.SetStatusOperation().Status(rctx, obj)
8495 })
8496 if err != nil {
8497 ec.Error(ctx, err)
8498 return graphql.Null
8499 }
8500 if resTmp == nil {
8501 if !graphql.HasFieldError(ctx, fc) {
8502 ec.Errorf(ctx, "must not be null")
8503 }
8504 return graphql.Null
8505 }
8506 res := resTmp.(models.Status)
8507 fc.Result = res
8508 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8509}
8510
8511func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8512 defer func() {
8513 if r := recover(); r != nil {
8514 ec.Error(ctx, ec.Recover(ctx, r))
8515 ret = graphql.Null
8516 }
8517 }()
8518 fc := &graphql.FieldContext{
8519 Object: "SetStatusTimelineItem",
8520 Field: field,
8521 Args: nil,
8522 IsMethod: true,
8523 }
8524
8525 ctx = graphql.WithFieldContext(ctx, fc)
8526 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8527 ctx = rctx // use context from middleware stack in children
8528 return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
8529 })
8530 if err != nil {
8531 ec.Error(ctx, err)
8532 return graphql.Null
8533 }
8534 if resTmp == nil {
8535 if !graphql.HasFieldError(ctx, fc) {
8536 ec.Errorf(ctx, "must not be null")
8537 }
8538 return graphql.Null
8539 }
8540 res := resTmp.(string)
8541 fc.Result = res
8542 return ec.marshalNString2string(ctx, field.Selections, res)
8543}
8544
8545func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8546 defer func() {
8547 if r := recover(); r != nil {
8548 ec.Error(ctx, ec.Recover(ctx, r))
8549 ret = graphql.Null
8550 }
8551 }()
8552 fc := &graphql.FieldContext{
8553 Object: "SetStatusTimelineItem",
8554 Field: field,
8555 Args: nil,
8556 IsMethod: true,
8557 }
8558
8559 ctx = graphql.WithFieldContext(ctx, fc)
8560 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8561 ctx = rctx // use context from middleware stack in children
8562 return ec.resolvers.SetStatusTimelineItem().Author(rctx, obj)
8563 })
8564 if err != nil {
8565 ec.Error(ctx, err)
8566 return graphql.Null
8567 }
8568 if resTmp == nil {
8569 if !graphql.HasFieldError(ctx, fc) {
8570 ec.Errorf(ctx, "must not be null")
8571 }
8572 return graphql.Null
8573 }
8574 res := resTmp.(models.IdentityWrapper)
8575 fc.Result = res
8576 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8577}
8578
8579func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8580 defer func() {
8581 if r := recover(); r != nil {
8582 ec.Error(ctx, ec.Recover(ctx, r))
8583 ret = graphql.Null
8584 }
8585 }()
8586 fc := &graphql.FieldContext{
8587 Object: "SetStatusTimelineItem",
8588 Field: field,
8589 Args: nil,
8590 IsMethod: true,
8591 }
8592
8593 ctx = graphql.WithFieldContext(ctx, fc)
8594 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8595 ctx = rctx // use context from middleware stack in children
8596 return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
8597 })
8598 if err != nil {
8599 ec.Error(ctx, err)
8600 return graphql.Null
8601 }
8602 if resTmp == nil {
8603 if !graphql.HasFieldError(ctx, fc) {
8604 ec.Errorf(ctx, "must not be null")
8605 }
8606 return graphql.Null
8607 }
8608 res := resTmp.(*time.Time)
8609 fc.Result = res
8610 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8611}
8612
8613func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8614 defer func() {
8615 if r := recover(); r != nil {
8616 ec.Error(ctx, ec.Recover(ctx, r))
8617 ret = graphql.Null
8618 }
8619 }()
8620 fc := &graphql.FieldContext{
8621 Object: "SetStatusTimelineItem",
8622 Field: field,
8623 Args: nil,
8624 IsMethod: true,
8625 }
8626
8627 ctx = graphql.WithFieldContext(ctx, fc)
8628 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8629 ctx = rctx // use context from middleware stack in children
8630 return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
8631 })
8632 if err != nil {
8633 ec.Error(ctx, err)
8634 return graphql.Null
8635 }
8636 if resTmp == nil {
8637 if !graphql.HasFieldError(ctx, fc) {
8638 ec.Errorf(ctx, "must not be null")
8639 }
8640 return graphql.Null
8641 }
8642 res := resTmp.(models.Status)
8643 fc.Result = res
8644 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8645}
8646
8647func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8648 defer func() {
8649 if r := recover(); r != nil {
8650 ec.Error(ctx, ec.Recover(ctx, r))
8651 ret = graphql.Null
8652 }
8653 }()
8654 fc := &graphql.FieldContext{
8655 Object: "SetTitleOperation",
8656 Field: field,
8657 Args: nil,
8658 IsMethod: true,
8659 }
8660
8661 ctx = graphql.WithFieldContext(ctx, fc)
8662 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8663 ctx = rctx // use context from middleware stack in children
8664 return ec.resolvers.SetTitleOperation().ID(rctx, obj)
8665 })
8666 if err != nil {
8667 ec.Error(ctx, err)
8668 return graphql.Null
8669 }
8670 if resTmp == nil {
8671 if !graphql.HasFieldError(ctx, fc) {
8672 ec.Errorf(ctx, "must not be null")
8673 }
8674 return graphql.Null
8675 }
8676 res := resTmp.(string)
8677 fc.Result = res
8678 return ec.marshalNString2string(ctx, field.Selections, res)
8679}
8680
8681func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8682 defer func() {
8683 if r := recover(); r != nil {
8684 ec.Error(ctx, ec.Recover(ctx, r))
8685 ret = graphql.Null
8686 }
8687 }()
8688 fc := &graphql.FieldContext{
8689 Object: "SetTitleOperation",
8690 Field: field,
8691 Args: nil,
8692 IsMethod: true,
8693 }
8694
8695 ctx = graphql.WithFieldContext(ctx, fc)
8696 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8697 ctx = rctx // use context from middleware stack in children
8698 return ec.resolvers.SetTitleOperation().Author(rctx, obj)
8699 })
8700 if err != nil {
8701 ec.Error(ctx, err)
8702 return graphql.Null
8703 }
8704 if resTmp == nil {
8705 if !graphql.HasFieldError(ctx, fc) {
8706 ec.Errorf(ctx, "must not be null")
8707 }
8708 return graphql.Null
8709 }
8710 res := resTmp.(models.IdentityWrapper)
8711 fc.Result = res
8712 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8713}
8714
8715func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8716 defer func() {
8717 if r := recover(); r != nil {
8718 ec.Error(ctx, ec.Recover(ctx, r))
8719 ret = graphql.Null
8720 }
8721 }()
8722 fc := &graphql.FieldContext{
8723 Object: "SetTitleOperation",
8724 Field: field,
8725 Args: nil,
8726 IsMethod: true,
8727 }
8728
8729 ctx = graphql.WithFieldContext(ctx, fc)
8730 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8731 ctx = rctx // use context from middleware stack in children
8732 return ec.resolvers.SetTitleOperation().Date(rctx, obj)
8733 })
8734 if err != nil {
8735 ec.Error(ctx, err)
8736 return graphql.Null
8737 }
8738 if resTmp == nil {
8739 if !graphql.HasFieldError(ctx, fc) {
8740 ec.Errorf(ctx, "must not be null")
8741 }
8742 return graphql.Null
8743 }
8744 res := resTmp.(*time.Time)
8745 fc.Result = res
8746 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8747}
8748
8749func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8750 defer func() {
8751 if r := recover(); r != nil {
8752 ec.Error(ctx, ec.Recover(ctx, r))
8753 ret = graphql.Null
8754 }
8755 }()
8756 fc := &graphql.FieldContext{
8757 Object: "SetTitleOperation",
8758 Field: field,
8759 Args: nil,
8760 IsMethod: false,
8761 }
8762
8763 ctx = graphql.WithFieldContext(ctx, fc)
8764 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8765 ctx = rctx // use context from middleware stack in children
8766 return obj.Title, nil
8767 })
8768 if err != nil {
8769 ec.Error(ctx, err)
8770 return graphql.Null
8771 }
8772 if resTmp == nil {
8773 if !graphql.HasFieldError(ctx, fc) {
8774 ec.Errorf(ctx, "must not be null")
8775 }
8776 return graphql.Null
8777 }
8778 res := resTmp.(string)
8779 fc.Result = res
8780 return ec.marshalNString2string(ctx, field.Selections, res)
8781}
8782
8783func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8784 defer func() {
8785 if r := recover(); r != nil {
8786 ec.Error(ctx, ec.Recover(ctx, r))
8787 ret = graphql.Null
8788 }
8789 }()
8790 fc := &graphql.FieldContext{
8791 Object: "SetTitleOperation",
8792 Field: field,
8793 Args: nil,
8794 IsMethod: false,
8795 }
8796
8797 ctx = graphql.WithFieldContext(ctx, fc)
8798 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8799 ctx = rctx // use context from middleware stack in children
8800 return obj.Was, nil
8801 })
8802 if err != nil {
8803 ec.Error(ctx, err)
8804 return graphql.Null
8805 }
8806 if resTmp == nil {
8807 if !graphql.HasFieldError(ctx, fc) {
8808 ec.Errorf(ctx, "must not be null")
8809 }
8810 return graphql.Null
8811 }
8812 res := resTmp.(string)
8813 fc.Result = res
8814 return ec.marshalNString2string(ctx, field.Selections, res)
8815}
8816
8817func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8818 defer func() {
8819 if r := recover(); r != nil {
8820 ec.Error(ctx, ec.Recover(ctx, r))
8821 ret = graphql.Null
8822 }
8823 }()
8824 fc := &graphql.FieldContext{
8825 Object: "SetTitlePayload",
8826 Field: field,
8827 Args: nil,
8828 IsMethod: false,
8829 }
8830
8831 ctx = graphql.WithFieldContext(ctx, fc)
8832 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8833 ctx = rctx // use context from middleware stack in children
8834 return obj.ClientMutationID, nil
8835 })
8836 if err != nil {
8837 ec.Error(ctx, err)
8838 return graphql.Null
8839 }
8840 if resTmp == nil {
8841 return graphql.Null
8842 }
8843 res := resTmp.(*string)
8844 fc.Result = res
8845 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
8846}
8847
8848func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8849 defer func() {
8850 if r := recover(); r != nil {
8851 ec.Error(ctx, ec.Recover(ctx, r))
8852 ret = graphql.Null
8853 }
8854 }()
8855 fc := &graphql.FieldContext{
8856 Object: "SetTitlePayload",
8857 Field: field,
8858 Args: nil,
8859 IsMethod: false,
8860 }
8861
8862 ctx = graphql.WithFieldContext(ctx, fc)
8863 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8864 ctx = rctx // use context from middleware stack in children
8865 return obj.Bug, nil
8866 })
8867 if err != nil {
8868 ec.Error(ctx, err)
8869 return graphql.Null
8870 }
8871 if resTmp == nil {
8872 if !graphql.HasFieldError(ctx, fc) {
8873 ec.Errorf(ctx, "must not be null")
8874 }
8875 return graphql.Null
8876 }
8877 res := resTmp.(models.BugWrapper)
8878 fc.Result = res
8879 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
8880}
8881
8882func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8883 defer func() {
8884 if r := recover(); r != nil {
8885 ec.Error(ctx, ec.Recover(ctx, r))
8886 ret = graphql.Null
8887 }
8888 }()
8889 fc := &graphql.FieldContext{
8890 Object: "SetTitlePayload",
8891 Field: field,
8892 Args: nil,
8893 IsMethod: false,
8894 }
8895
8896 ctx = graphql.WithFieldContext(ctx, fc)
8897 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8898 ctx = rctx // use context from middleware stack in children
8899 return obj.Operation, nil
8900 })
8901 if err != nil {
8902 ec.Error(ctx, err)
8903 return graphql.Null
8904 }
8905 if resTmp == nil {
8906 if !graphql.HasFieldError(ctx, fc) {
8907 ec.Errorf(ctx, "must not be null")
8908 }
8909 return graphql.Null
8910 }
8911 res := resTmp.(*bug.SetTitleOperation)
8912 fc.Result = res
8913 return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
8914}
8915
8916func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
8917 defer func() {
8918 if r := recover(); r != nil {
8919 ec.Error(ctx, ec.Recover(ctx, r))
8920 ret = graphql.Null
8921 }
8922 }()
8923 fc := &graphql.FieldContext{
8924 Object: "SetTitleTimelineItem",
8925 Field: field,
8926 Args: nil,
8927 IsMethod: true,
8928 }
8929
8930 ctx = graphql.WithFieldContext(ctx, fc)
8931 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8932 ctx = rctx // use context from middleware stack in children
8933 return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
8934 })
8935 if err != nil {
8936 ec.Error(ctx, err)
8937 return graphql.Null
8938 }
8939 if resTmp == nil {
8940 if !graphql.HasFieldError(ctx, fc) {
8941 ec.Errorf(ctx, "must not be null")
8942 }
8943 return graphql.Null
8944 }
8945 res := resTmp.(string)
8946 fc.Result = res
8947 return ec.marshalNString2string(ctx, field.Selections, res)
8948}
8949
8950func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
8951 defer func() {
8952 if r := recover(); r != nil {
8953 ec.Error(ctx, ec.Recover(ctx, r))
8954 ret = graphql.Null
8955 }
8956 }()
8957 fc := &graphql.FieldContext{
8958 Object: "SetTitleTimelineItem",
8959 Field: field,
8960 Args: nil,
8961 IsMethod: true,
8962 }
8963
8964 ctx = graphql.WithFieldContext(ctx, fc)
8965 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8966 ctx = rctx // use context from middleware stack in children
8967 return ec.resolvers.SetTitleTimelineItem().Author(rctx, obj)
8968 })
8969 if err != nil {
8970 ec.Error(ctx, err)
8971 return graphql.Null
8972 }
8973 if resTmp == nil {
8974 if !graphql.HasFieldError(ctx, fc) {
8975 ec.Errorf(ctx, "must not be null")
8976 }
8977 return graphql.Null
8978 }
8979 res := resTmp.(models.IdentityWrapper)
8980 fc.Result = res
8981 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8982}
8983
8984func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
8985 defer func() {
8986 if r := recover(); r != nil {
8987 ec.Error(ctx, ec.Recover(ctx, r))
8988 ret = graphql.Null
8989 }
8990 }()
8991 fc := &graphql.FieldContext{
8992 Object: "SetTitleTimelineItem",
8993 Field: field,
8994 Args: nil,
8995 IsMethod: true,
8996 }
8997
8998 ctx = graphql.WithFieldContext(ctx, fc)
8999 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9000 ctx = rctx // use context from middleware stack in children
9001 return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
9002 })
9003 if err != nil {
9004 ec.Error(ctx, err)
9005 return graphql.Null
9006 }
9007 if resTmp == nil {
9008 if !graphql.HasFieldError(ctx, fc) {
9009 ec.Errorf(ctx, "must not be null")
9010 }
9011 return graphql.Null
9012 }
9013 res := resTmp.(*time.Time)
9014 fc.Result = res
9015 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
9016}
9017
9018func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9019 defer func() {
9020 if r := recover(); r != nil {
9021 ec.Error(ctx, ec.Recover(ctx, r))
9022 ret = graphql.Null
9023 }
9024 }()
9025 fc := &graphql.FieldContext{
9026 Object: "SetTitleTimelineItem",
9027 Field: field,
9028 Args: nil,
9029 IsMethod: false,
9030 }
9031
9032 ctx = graphql.WithFieldContext(ctx, fc)
9033 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9034 ctx = rctx // use context from middleware stack in children
9035 return obj.Title, nil
9036 })
9037 if err != nil {
9038 ec.Error(ctx, err)
9039 return graphql.Null
9040 }
9041 if resTmp == nil {
9042 if !graphql.HasFieldError(ctx, fc) {
9043 ec.Errorf(ctx, "must not be null")
9044 }
9045 return graphql.Null
9046 }
9047 res := resTmp.(string)
9048 fc.Result = res
9049 return ec.marshalNString2string(ctx, field.Selections, res)
9050}
9051
9052func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9053 defer func() {
9054 if r := recover(); r != nil {
9055 ec.Error(ctx, ec.Recover(ctx, r))
9056 ret = graphql.Null
9057 }
9058 }()
9059 fc := &graphql.FieldContext{
9060 Object: "SetTitleTimelineItem",
9061 Field: field,
9062 Args: nil,
9063 IsMethod: false,
9064 }
9065
9066 ctx = graphql.WithFieldContext(ctx, fc)
9067 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9068 ctx = rctx // use context from middleware stack in children
9069 return obj.Was, nil
9070 })
9071 if err != nil {
9072 ec.Error(ctx, err)
9073 return graphql.Null
9074 }
9075 if resTmp == nil {
9076 if !graphql.HasFieldError(ctx, fc) {
9077 ec.Errorf(ctx, "must not be null")
9078 }
9079 return graphql.Null
9080 }
9081 res := resTmp.(string)
9082 fc.Result = res
9083 return ec.marshalNString2string(ctx, field.Selections, res)
9084}
9085
9086func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9087 defer func() {
9088 if r := recover(); r != nil {
9089 ec.Error(ctx, ec.Recover(ctx, r))
9090 ret = graphql.Null
9091 }
9092 }()
9093 fc := &graphql.FieldContext{
9094 Object: "TimelineItemConnection",
9095 Field: field,
9096 Args: nil,
9097 IsMethod: false,
9098 }
9099
9100 ctx = graphql.WithFieldContext(ctx, fc)
9101 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9102 ctx = rctx // use context from middleware stack in children
9103 return obj.Edges, nil
9104 })
9105 if err != nil {
9106 ec.Error(ctx, err)
9107 return graphql.Null
9108 }
9109 if resTmp == nil {
9110 if !graphql.HasFieldError(ctx, fc) {
9111 ec.Errorf(ctx, "must not be null")
9112 }
9113 return graphql.Null
9114 }
9115 res := resTmp.([]*models.TimelineItemEdge)
9116 fc.Result = res
9117 return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx, field.Selections, res)
9118}
9119
9120func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9121 defer func() {
9122 if r := recover(); r != nil {
9123 ec.Error(ctx, ec.Recover(ctx, r))
9124 ret = graphql.Null
9125 }
9126 }()
9127 fc := &graphql.FieldContext{
9128 Object: "TimelineItemConnection",
9129 Field: field,
9130 Args: nil,
9131 IsMethod: false,
9132 }
9133
9134 ctx = graphql.WithFieldContext(ctx, fc)
9135 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9136 ctx = rctx // use context from middleware stack in children
9137 return obj.Nodes, nil
9138 })
9139 if err != nil {
9140 ec.Error(ctx, err)
9141 return graphql.Null
9142 }
9143 if resTmp == nil {
9144 if !graphql.HasFieldError(ctx, fc) {
9145 ec.Errorf(ctx, "must not be null")
9146 }
9147 return graphql.Null
9148 }
9149 res := resTmp.([]bug.TimelineItem)
9150 fc.Result = res
9151 return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx, field.Selections, res)
9152}
9153
9154func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9155 defer func() {
9156 if r := recover(); r != nil {
9157 ec.Error(ctx, ec.Recover(ctx, r))
9158 ret = graphql.Null
9159 }
9160 }()
9161 fc := &graphql.FieldContext{
9162 Object: "TimelineItemConnection",
9163 Field: field,
9164 Args: nil,
9165 IsMethod: false,
9166 }
9167
9168 ctx = graphql.WithFieldContext(ctx, fc)
9169 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9170 ctx = rctx // use context from middleware stack in children
9171 return obj.PageInfo, nil
9172 })
9173 if err != nil {
9174 ec.Error(ctx, err)
9175 return graphql.Null
9176 }
9177 if resTmp == nil {
9178 if !graphql.HasFieldError(ctx, fc) {
9179 ec.Errorf(ctx, "must not be null")
9180 }
9181 return graphql.Null
9182 }
9183 res := resTmp.(*models.PageInfo)
9184 fc.Result = res
9185 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
9186}
9187
9188func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9189 defer func() {
9190 if r := recover(); r != nil {
9191 ec.Error(ctx, ec.Recover(ctx, r))
9192 ret = graphql.Null
9193 }
9194 }()
9195 fc := &graphql.FieldContext{
9196 Object: "TimelineItemConnection",
9197 Field: field,
9198 Args: nil,
9199 IsMethod: false,
9200 }
9201
9202 ctx = graphql.WithFieldContext(ctx, fc)
9203 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9204 ctx = rctx // use context from middleware stack in children
9205 return obj.TotalCount, nil
9206 })
9207 if err != nil {
9208 ec.Error(ctx, err)
9209 return graphql.Null
9210 }
9211 if resTmp == nil {
9212 if !graphql.HasFieldError(ctx, fc) {
9213 ec.Errorf(ctx, "must not be null")
9214 }
9215 return graphql.Null
9216 }
9217 res := resTmp.(int)
9218 fc.Result = res
9219 return ec.marshalNInt2int(ctx, field.Selections, res)
9220}
9221
9222func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9223 defer func() {
9224 if r := recover(); r != nil {
9225 ec.Error(ctx, ec.Recover(ctx, r))
9226 ret = graphql.Null
9227 }
9228 }()
9229 fc := &graphql.FieldContext{
9230 Object: "TimelineItemEdge",
9231 Field: field,
9232 Args: nil,
9233 IsMethod: false,
9234 }
9235
9236 ctx = graphql.WithFieldContext(ctx, fc)
9237 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9238 ctx = rctx // use context from middleware stack in children
9239 return obj.Cursor, nil
9240 })
9241 if err != nil {
9242 ec.Error(ctx, err)
9243 return graphql.Null
9244 }
9245 if resTmp == nil {
9246 if !graphql.HasFieldError(ctx, fc) {
9247 ec.Errorf(ctx, "must not be null")
9248 }
9249 return graphql.Null
9250 }
9251 res := resTmp.(string)
9252 fc.Result = res
9253 return ec.marshalNString2string(ctx, field.Selections, res)
9254}
9255
9256func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9257 defer func() {
9258 if r := recover(); r != nil {
9259 ec.Error(ctx, ec.Recover(ctx, r))
9260 ret = graphql.Null
9261 }
9262 }()
9263 fc := &graphql.FieldContext{
9264 Object: "TimelineItemEdge",
9265 Field: field,
9266 Args: nil,
9267 IsMethod: false,
9268 }
9269
9270 ctx = graphql.WithFieldContext(ctx, fc)
9271 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9272 ctx = rctx // use context from middleware stack in children
9273 return obj.Node, nil
9274 })
9275 if err != nil {
9276 ec.Error(ctx, err)
9277 return graphql.Null
9278 }
9279 if resTmp == nil {
9280 if !graphql.HasFieldError(ctx, fc) {
9281 ec.Errorf(ctx, "must not be null")
9282 }
9283 return graphql.Null
9284 }
9285 res := resTmp.(bug.TimelineItem)
9286 fc.Result = res
9287 return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
9288}
9289
9290func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9291 defer func() {
9292 if r := recover(); r != nil {
9293 ec.Error(ctx, ec.Recover(ctx, r))
9294 ret = graphql.Null
9295 }
9296 }()
9297 fc := &graphql.FieldContext{
9298 Object: "__Directive",
9299 Field: field,
9300 Args: nil,
9301 IsMethod: false,
9302 }
9303
9304 ctx = graphql.WithFieldContext(ctx, fc)
9305 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9306 ctx = rctx // use context from middleware stack in children
9307 return obj.Name, nil
9308 })
9309 if err != nil {
9310 ec.Error(ctx, err)
9311 return graphql.Null
9312 }
9313 if resTmp == nil {
9314 if !graphql.HasFieldError(ctx, fc) {
9315 ec.Errorf(ctx, "must not be null")
9316 }
9317 return graphql.Null
9318 }
9319 res := resTmp.(string)
9320 fc.Result = res
9321 return ec.marshalNString2string(ctx, field.Selections, res)
9322}
9323
9324func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9325 defer func() {
9326 if r := recover(); r != nil {
9327 ec.Error(ctx, ec.Recover(ctx, r))
9328 ret = graphql.Null
9329 }
9330 }()
9331 fc := &graphql.FieldContext{
9332 Object: "__Directive",
9333 Field: field,
9334 Args: nil,
9335 IsMethod: false,
9336 }
9337
9338 ctx = graphql.WithFieldContext(ctx, fc)
9339 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9340 ctx = rctx // use context from middleware stack in children
9341 return obj.Description, nil
9342 })
9343 if err != nil {
9344 ec.Error(ctx, err)
9345 return graphql.Null
9346 }
9347 if resTmp == nil {
9348 return graphql.Null
9349 }
9350 res := resTmp.(string)
9351 fc.Result = res
9352 return ec.marshalOString2string(ctx, field.Selections, res)
9353}
9354
9355func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9356 defer func() {
9357 if r := recover(); r != nil {
9358 ec.Error(ctx, ec.Recover(ctx, r))
9359 ret = graphql.Null
9360 }
9361 }()
9362 fc := &graphql.FieldContext{
9363 Object: "__Directive",
9364 Field: field,
9365 Args: nil,
9366 IsMethod: false,
9367 }
9368
9369 ctx = graphql.WithFieldContext(ctx, fc)
9370 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9371 ctx = rctx // use context from middleware stack in children
9372 return obj.Locations, nil
9373 })
9374 if err != nil {
9375 ec.Error(ctx, err)
9376 return graphql.Null
9377 }
9378 if resTmp == nil {
9379 if !graphql.HasFieldError(ctx, fc) {
9380 ec.Errorf(ctx, "must not be null")
9381 }
9382 return graphql.Null
9383 }
9384 res := resTmp.([]string)
9385 fc.Result = res
9386 return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
9387}
9388
9389func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9390 defer func() {
9391 if r := recover(); r != nil {
9392 ec.Error(ctx, ec.Recover(ctx, r))
9393 ret = graphql.Null
9394 }
9395 }()
9396 fc := &graphql.FieldContext{
9397 Object: "__Directive",
9398 Field: field,
9399 Args: nil,
9400 IsMethod: false,
9401 }
9402
9403 ctx = graphql.WithFieldContext(ctx, fc)
9404 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9405 ctx = rctx // use context from middleware stack in children
9406 return obj.Args, nil
9407 })
9408 if err != nil {
9409 ec.Error(ctx, err)
9410 return graphql.Null
9411 }
9412 if resTmp == nil {
9413 if !graphql.HasFieldError(ctx, fc) {
9414 ec.Errorf(ctx, "must not be null")
9415 }
9416 return graphql.Null
9417 }
9418 res := resTmp.([]introspection.InputValue)
9419 fc.Result = res
9420 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
9421}
9422
9423func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9424 defer func() {
9425 if r := recover(); r != nil {
9426 ec.Error(ctx, ec.Recover(ctx, r))
9427 ret = graphql.Null
9428 }
9429 }()
9430 fc := &graphql.FieldContext{
9431 Object: "__EnumValue",
9432 Field: field,
9433 Args: nil,
9434 IsMethod: false,
9435 }
9436
9437 ctx = graphql.WithFieldContext(ctx, fc)
9438 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9439 ctx = rctx // use context from middleware stack in children
9440 return obj.Name, nil
9441 })
9442 if err != nil {
9443 ec.Error(ctx, err)
9444 return graphql.Null
9445 }
9446 if resTmp == nil {
9447 if !graphql.HasFieldError(ctx, fc) {
9448 ec.Errorf(ctx, "must not be null")
9449 }
9450 return graphql.Null
9451 }
9452 res := resTmp.(string)
9453 fc.Result = res
9454 return ec.marshalNString2string(ctx, field.Selections, res)
9455}
9456
9457func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9458 defer func() {
9459 if r := recover(); r != nil {
9460 ec.Error(ctx, ec.Recover(ctx, r))
9461 ret = graphql.Null
9462 }
9463 }()
9464 fc := &graphql.FieldContext{
9465 Object: "__EnumValue",
9466 Field: field,
9467 Args: nil,
9468 IsMethod: false,
9469 }
9470
9471 ctx = graphql.WithFieldContext(ctx, fc)
9472 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9473 ctx = rctx // use context from middleware stack in children
9474 return obj.Description, nil
9475 })
9476 if err != nil {
9477 ec.Error(ctx, err)
9478 return graphql.Null
9479 }
9480 if resTmp == nil {
9481 return graphql.Null
9482 }
9483 res := resTmp.(string)
9484 fc.Result = res
9485 return ec.marshalOString2string(ctx, field.Selections, res)
9486}
9487
9488func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9489 defer func() {
9490 if r := recover(); r != nil {
9491 ec.Error(ctx, ec.Recover(ctx, r))
9492 ret = graphql.Null
9493 }
9494 }()
9495 fc := &graphql.FieldContext{
9496 Object: "__EnumValue",
9497 Field: field,
9498 Args: nil,
9499 IsMethod: true,
9500 }
9501
9502 ctx = graphql.WithFieldContext(ctx, fc)
9503 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9504 ctx = rctx // use context from middleware stack in children
9505 return obj.IsDeprecated(), nil
9506 })
9507 if err != nil {
9508 ec.Error(ctx, err)
9509 return graphql.Null
9510 }
9511 if resTmp == nil {
9512 if !graphql.HasFieldError(ctx, fc) {
9513 ec.Errorf(ctx, "must not be null")
9514 }
9515 return graphql.Null
9516 }
9517 res := resTmp.(bool)
9518 fc.Result = res
9519 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9520}
9521
9522func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9523 defer func() {
9524 if r := recover(); r != nil {
9525 ec.Error(ctx, ec.Recover(ctx, r))
9526 ret = graphql.Null
9527 }
9528 }()
9529 fc := &graphql.FieldContext{
9530 Object: "__EnumValue",
9531 Field: field,
9532 Args: nil,
9533 IsMethod: true,
9534 }
9535
9536 ctx = graphql.WithFieldContext(ctx, fc)
9537 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9538 ctx = rctx // use context from middleware stack in children
9539 return obj.DeprecationReason(), nil
9540 })
9541 if err != nil {
9542 ec.Error(ctx, err)
9543 return graphql.Null
9544 }
9545 if resTmp == nil {
9546 return graphql.Null
9547 }
9548 res := resTmp.(*string)
9549 fc.Result = res
9550 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9551}
9552
9553func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9554 defer func() {
9555 if r := recover(); r != nil {
9556 ec.Error(ctx, ec.Recover(ctx, r))
9557 ret = graphql.Null
9558 }
9559 }()
9560 fc := &graphql.FieldContext{
9561 Object: "__Field",
9562 Field: field,
9563 Args: nil,
9564 IsMethod: false,
9565 }
9566
9567 ctx = graphql.WithFieldContext(ctx, fc)
9568 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9569 ctx = rctx // use context from middleware stack in children
9570 return obj.Name, nil
9571 })
9572 if err != nil {
9573 ec.Error(ctx, err)
9574 return graphql.Null
9575 }
9576 if resTmp == nil {
9577 if !graphql.HasFieldError(ctx, fc) {
9578 ec.Errorf(ctx, "must not be null")
9579 }
9580 return graphql.Null
9581 }
9582 res := resTmp.(string)
9583 fc.Result = res
9584 return ec.marshalNString2string(ctx, field.Selections, res)
9585}
9586
9587func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9588 defer func() {
9589 if r := recover(); r != nil {
9590 ec.Error(ctx, ec.Recover(ctx, r))
9591 ret = graphql.Null
9592 }
9593 }()
9594 fc := &graphql.FieldContext{
9595 Object: "__Field",
9596 Field: field,
9597 Args: nil,
9598 IsMethod: false,
9599 }
9600
9601 ctx = graphql.WithFieldContext(ctx, fc)
9602 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9603 ctx = rctx // use context from middleware stack in children
9604 return obj.Description, nil
9605 })
9606 if err != nil {
9607 ec.Error(ctx, err)
9608 return graphql.Null
9609 }
9610 if resTmp == nil {
9611 return graphql.Null
9612 }
9613 res := resTmp.(string)
9614 fc.Result = res
9615 return ec.marshalOString2string(ctx, field.Selections, res)
9616}
9617
9618func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9619 defer func() {
9620 if r := recover(); r != nil {
9621 ec.Error(ctx, ec.Recover(ctx, r))
9622 ret = graphql.Null
9623 }
9624 }()
9625 fc := &graphql.FieldContext{
9626 Object: "__Field",
9627 Field: field,
9628 Args: nil,
9629 IsMethod: false,
9630 }
9631
9632 ctx = graphql.WithFieldContext(ctx, fc)
9633 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9634 ctx = rctx // use context from middleware stack in children
9635 return obj.Args, nil
9636 })
9637 if err != nil {
9638 ec.Error(ctx, err)
9639 return graphql.Null
9640 }
9641 if resTmp == nil {
9642 if !graphql.HasFieldError(ctx, fc) {
9643 ec.Errorf(ctx, "must not be null")
9644 }
9645 return graphql.Null
9646 }
9647 res := resTmp.([]introspection.InputValue)
9648 fc.Result = res
9649 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
9650}
9651
9652func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9653 defer func() {
9654 if r := recover(); r != nil {
9655 ec.Error(ctx, ec.Recover(ctx, r))
9656 ret = graphql.Null
9657 }
9658 }()
9659 fc := &graphql.FieldContext{
9660 Object: "__Field",
9661 Field: field,
9662 Args: nil,
9663 IsMethod: false,
9664 }
9665
9666 ctx = graphql.WithFieldContext(ctx, fc)
9667 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9668 ctx = rctx // use context from middleware stack in children
9669 return obj.Type, nil
9670 })
9671 if err != nil {
9672 ec.Error(ctx, err)
9673 return graphql.Null
9674 }
9675 if resTmp == nil {
9676 if !graphql.HasFieldError(ctx, fc) {
9677 ec.Errorf(ctx, "must not be null")
9678 }
9679 return graphql.Null
9680 }
9681 res := resTmp.(*introspection.Type)
9682 fc.Result = res
9683 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9684}
9685
9686func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9687 defer func() {
9688 if r := recover(); r != nil {
9689 ec.Error(ctx, ec.Recover(ctx, r))
9690 ret = graphql.Null
9691 }
9692 }()
9693 fc := &graphql.FieldContext{
9694 Object: "__Field",
9695 Field: field,
9696 Args: nil,
9697 IsMethod: true,
9698 }
9699
9700 ctx = graphql.WithFieldContext(ctx, fc)
9701 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9702 ctx = rctx // use context from middleware stack in children
9703 return obj.IsDeprecated(), nil
9704 })
9705 if err != nil {
9706 ec.Error(ctx, err)
9707 return graphql.Null
9708 }
9709 if resTmp == nil {
9710 if !graphql.HasFieldError(ctx, fc) {
9711 ec.Errorf(ctx, "must not be null")
9712 }
9713 return graphql.Null
9714 }
9715 res := resTmp.(bool)
9716 fc.Result = res
9717 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9718}
9719
9720func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9721 defer func() {
9722 if r := recover(); r != nil {
9723 ec.Error(ctx, ec.Recover(ctx, r))
9724 ret = graphql.Null
9725 }
9726 }()
9727 fc := &graphql.FieldContext{
9728 Object: "__Field",
9729 Field: field,
9730 Args: nil,
9731 IsMethod: true,
9732 }
9733
9734 ctx = graphql.WithFieldContext(ctx, fc)
9735 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9736 ctx = rctx // use context from middleware stack in children
9737 return obj.DeprecationReason(), nil
9738 })
9739 if err != nil {
9740 ec.Error(ctx, err)
9741 return graphql.Null
9742 }
9743 if resTmp == nil {
9744 return graphql.Null
9745 }
9746 res := resTmp.(*string)
9747 fc.Result = res
9748 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9749}
9750
9751func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9752 defer func() {
9753 if r := recover(); r != nil {
9754 ec.Error(ctx, ec.Recover(ctx, r))
9755 ret = graphql.Null
9756 }
9757 }()
9758 fc := &graphql.FieldContext{
9759 Object: "__InputValue",
9760 Field: field,
9761 Args: nil,
9762 IsMethod: false,
9763 }
9764
9765 ctx = graphql.WithFieldContext(ctx, fc)
9766 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9767 ctx = rctx // use context from middleware stack in children
9768 return obj.Name, nil
9769 })
9770 if err != nil {
9771 ec.Error(ctx, err)
9772 return graphql.Null
9773 }
9774 if resTmp == nil {
9775 if !graphql.HasFieldError(ctx, fc) {
9776 ec.Errorf(ctx, "must not be null")
9777 }
9778 return graphql.Null
9779 }
9780 res := resTmp.(string)
9781 fc.Result = res
9782 return ec.marshalNString2string(ctx, field.Selections, res)
9783}
9784
9785func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9786 defer func() {
9787 if r := recover(); r != nil {
9788 ec.Error(ctx, ec.Recover(ctx, r))
9789 ret = graphql.Null
9790 }
9791 }()
9792 fc := &graphql.FieldContext{
9793 Object: "__InputValue",
9794 Field: field,
9795 Args: nil,
9796 IsMethod: false,
9797 }
9798
9799 ctx = graphql.WithFieldContext(ctx, fc)
9800 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9801 ctx = rctx // use context from middleware stack in children
9802 return obj.Description, nil
9803 })
9804 if err != nil {
9805 ec.Error(ctx, err)
9806 return graphql.Null
9807 }
9808 if resTmp == nil {
9809 return graphql.Null
9810 }
9811 res := resTmp.(string)
9812 fc.Result = res
9813 return ec.marshalOString2string(ctx, field.Selections, res)
9814}
9815
9816func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9817 defer func() {
9818 if r := recover(); r != nil {
9819 ec.Error(ctx, ec.Recover(ctx, r))
9820 ret = graphql.Null
9821 }
9822 }()
9823 fc := &graphql.FieldContext{
9824 Object: "__InputValue",
9825 Field: field,
9826 Args: nil,
9827 IsMethod: false,
9828 }
9829
9830 ctx = graphql.WithFieldContext(ctx, fc)
9831 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9832 ctx = rctx // use context from middleware stack in children
9833 return obj.Type, nil
9834 })
9835 if err != nil {
9836 ec.Error(ctx, err)
9837 return graphql.Null
9838 }
9839 if resTmp == nil {
9840 if !graphql.HasFieldError(ctx, fc) {
9841 ec.Errorf(ctx, "must not be null")
9842 }
9843 return graphql.Null
9844 }
9845 res := resTmp.(*introspection.Type)
9846 fc.Result = res
9847 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9848}
9849
9850func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9851 defer func() {
9852 if r := recover(); r != nil {
9853 ec.Error(ctx, ec.Recover(ctx, r))
9854 ret = graphql.Null
9855 }
9856 }()
9857 fc := &graphql.FieldContext{
9858 Object: "__InputValue",
9859 Field: field,
9860 Args: nil,
9861 IsMethod: false,
9862 }
9863
9864 ctx = graphql.WithFieldContext(ctx, fc)
9865 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9866 ctx = rctx // use context from middleware stack in children
9867 return obj.DefaultValue, nil
9868 })
9869 if err != nil {
9870 ec.Error(ctx, err)
9871 return graphql.Null
9872 }
9873 if resTmp == nil {
9874 return graphql.Null
9875 }
9876 res := resTmp.(*string)
9877 fc.Result = res
9878 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9879}
9880
9881func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
9882 defer func() {
9883 if r := recover(); r != nil {
9884 ec.Error(ctx, ec.Recover(ctx, r))
9885 ret = graphql.Null
9886 }
9887 }()
9888 fc := &graphql.FieldContext{
9889 Object: "__Schema",
9890 Field: field,
9891 Args: nil,
9892 IsMethod: true,
9893 }
9894
9895 ctx = graphql.WithFieldContext(ctx, fc)
9896 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9897 ctx = rctx // use context from middleware stack in children
9898 return obj.Types(), nil
9899 })
9900 if err != nil {
9901 ec.Error(ctx, err)
9902 return graphql.Null
9903 }
9904 if resTmp == nil {
9905 if !graphql.HasFieldError(ctx, fc) {
9906 ec.Errorf(ctx, "must not be null")
9907 }
9908 return graphql.Null
9909 }
9910 res := resTmp.([]introspection.Type)
9911 fc.Result = res
9912 return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
9913}
9914
9915func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
9916 defer func() {
9917 if r := recover(); r != nil {
9918 ec.Error(ctx, ec.Recover(ctx, r))
9919 ret = graphql.Null
9920 }
9921 }()
9922 fc := &graphql.FieldContext{
9923 Object: "__Schema",
9924 Field: field,
9925 Args: nil,
9926 IsMethod: true,
9927 }
9928
9929 ctx = graphql.WithFieldContext(ctx, fc)
9930 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9931 ctx = rctx // use context from middleware stack in children
9932 return obj.QueryType(), nil
9933 })
9934 if err != nil {
9935 ec.Error(ctx, err)
9936 return graphql.Null
9937 }
9938 if resTmp == nil {
9939 if !graphql.HasFieldError(ctx, fc) {
9940 ec.Errorf(ctx, "must not be null")
9941 }
9942 return graphql.Null
9943 }
9944 res := resTmp.(*introspection.Type)
9945 fc.Result = res
9946 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9947}
9948
9949func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
9950 defer func() {
9951 if r := recover(); r != nil {
9952 ec.Error(ctx, ec.Recover(ctx, r))
9953 ret = graphql.Null
9954 }
9955 }()
9956 fc := &graphql.FieldContext{
9957 Object: "__Schema",
9958 Field: field,
9959 Args: nil,
9960 IsMethod: true,
9961 }
9962
9963 ctx = graphql.WithFieldContext(ctx, fc)
9964 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9965 ctx = rctx // use context from middleware stack in children
9966 return obj.MutationType(), nil
9967 })
9968 if err != nil {
9969 ec.Error(ctx, err)
9970 return graphql.Null
9971 }
9972 if resTmp == nil {
9973 return graphql.Null
9974 }
9975 res := resTmp.(*introspection.Type)
9976 fc.Result = res
9977 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9978}
9979
9980func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
9981 defer func() {
9982 if r := recover(); r != nil {
9983 ec.Error(ctx, ec.Recover(ctx, r))
9984 ret = graphql.Null
9985 }
9986 }()
9987 fc := &graphql.FieldContext{
9988 Object: "__Schema",
9989 Field: field,
9990 Args: nil,
9991 IsMethod: true,
9992 }
9993
9994 ctx = graphql.WithFieldContext(ctx, fc)
9995 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9996 ctx = rctx // use context from middleware stack in children
9997 return obj.SubscriptionType(), nil
9998 })
9999 if err != nil {
10000 ec.Error(ctx, err)
10001 return graphql.Null
10002 }
10003 if resTmp == nil {
10004 return graphql.Null
10005 }
10006 res := resTmp.(*introspection.Type)
10007 fc.Result = res
10008 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10009}
10010
10011func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10012 defer func() {
10013 if r := recover(); r != nil {
10014 ec.Error(ctx, ec.Recover(ctx, r))
10015 ret = graphql.Null
10016 }
10017 }()
10018 fc := &graphql.FieldContext{
10019 Object: "__Schema",
10020 Field: field,
10021 Args: nil,
10022 IsMethod: true,
10023 }
10024
10025 ctx = graphql.WithFieldContext(ctx, fc)
10026 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10027 ctx = rctx // use context from middleware stack in children
10028 return obj.Directives(), nil
10029 })
10030 if err != nil {
10031 ec.Error(ctx, err)
10032 return graphql.Null
10033 }
10034 if resTmp == nil {
10035 if !graphql.HasFieldError(ctx, fc) {
10036 ec.Errorf(ctx, "must not be null")
10037 }
10038 return graphql.Null
10039 }
10040 res := resTmp.([]introspection.Directive)
10041 fc.Result = res
10042 return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
10043}
10044
10045func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10046 defer func() {
10047 if r := recover(); r != nil {
10048 ec.Error(ctx, ec.Recover(ctx, r))
10049 ret = graphql.Null
10050 }
10051 }()
10052 fc := &graphql.FieldContext{
10053 Object: "__Type",
10054 Field: field,
10055 Args: nil,
10056 IsMethod: true,
10057 }
10058
10059 ctx = graphql.WithFieldContext(ctx, fc)
10060 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10061 ctx = rctx // use context from middleware stack in children
10062 return obj.Kind(), nil
10063 })
10064 if err != nil {
10065 ec.Error(ctx, err)
10066 return graphql.Null
10067 }
10068 if resTmp == nil {
10069 if !graphql.HasFieldError(ctx, fc) {
10070 ec.Errorf(ctx, "must not be null")
10071 }
10072 return graphql.Null
10073 }
10074 res := resTmp.(string)
10075 fc.Result = res
10076 return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
10077}
10078
10079func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10080 defer func() {
10081 if r := recover(); r != nil {
10082 ec.Error(ctx, ec.Recover(ctx, r))
10083 ret = graphql.Null
10084 }
10085 }()
10086 fc := &graphql.FieldContext{
10087 Object: "__Type",
10088 Field: field,
10089 Args: nil,
10090 IsMethod: true,
10091 }
10092
10093 ctx = graphql.WithFieldContext(ctx, fc)
10094 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10095 ctx = rctx // use context from middleware stack in children
10096 return obj.Name(), nil
10097 })
10098 if err != nil {
10099 ec.Error(ctx, err)
10100 return graphql.Null
10101 }
10102 if resTmp == nil {
10103 return graphql.Null
10104 }
10105 res := resTmp.(*string)
10106 fc.Result = res
10107 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10108}
10109
10110func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10111 defer func() {
10112 if r := recover(); r != nil {
10113 ec.Error(ctx, ec.Recover(ctx, r))
10114 ret = graphql.Null
10115 }
10116 }()
10117 fc := &graphql.FieldContext{
10118 Object: "__Type",
10119 Field: field,
10120 Args: nil,
10121 IsMethod: true,
10122 }
10123
10124 ctx = graphql.WithFieldContext(ctx, fc)
10125 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10126 ctx = rctx // use context from middleware stack in children
10127 return obj.Description(), nil
10128 })
10129 if err != nil {
10130 ec.Error(ctx, err)
10131 return graphql.Null
10132 }
10133 if resTmp == nil {
10134 return graphql.Null
10135 }
10136 res := resTmp.(string)
10137 fc.Result = res
10138 return ec.marshalOString2string(ctx, field.Selections, res)
10139}
10140
10141func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10142 defer func() {
10143 if r := recover(); r != nil {
10144 ec.Error(ctx, ec.Recover(ctx, r))
10145 ret = graphql.Null
10146 }
10147 }()
10148 fc := &graphql.FieldContext{
10149 Object: "__Type",
10150 Field: field,
10151 Args: nil,
10152 IsMethod: true,
10153 }
10154
10155 ctx = graphql.WithFieldContext(ctx, fc)
10156 rawArgs := field.ArgumentMap(ec.Variables)
10157 args, err := ec.field___Type_fields_args(ctx, rawArgs)
10158 if err != nil {
10159 ec.Error(ctx, err)
10160 return graphql.Null
10161 }
10162 fc.Args = args
10163 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10164 ctx = rctx // use context from middleware stack in children
10165 return obj.Fields(args["includeDeprecated"].(bool)), nil
10166 })
10167 if err != nil {
10168 ec.Error(ctx, err)
10169 return graphql.Null
10170 }
10171 if resTmp == nil {
10172 return graphql.Null
10173 }
10174 res := resTmp.([]introspection.Field)
10175 fc.Result = res
10176 return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
10177}
10178
10179func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10180 defer func() {
10181 if r := recover(); r != nil {
10182 ec.Error(ctx, ec.Recover(ctx, r))
10183 ret = graphql.Null
10184 }
10185 }()
10186 fc := &graphql.FieldContext{
10187 Object: "__Type",
10188 Field: field,
10189 Args: nil,
10190 IsMethod: true,
10191 }
10192
10193 ctx = graphql.WithFieldContext(ctx, fc)
10194 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10195 ctx = rctx // use context from middleware stack in children
10196 return obj.Interfaces(), nil
10197 })
10198 if err != nil {
10199 ec.Error(ctx, err)
10200 return graphql.Null
10201 }
10202 if resTmp == nil {
10203 return graphql.Null
10204 }
10205 res := resTmp.([]introspection.Type)
10206 fc.Result = res
10207 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10208}
10209
10210func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10211 defer func() {
10212 if r := recover(); r != nil {
10213 ec.Error(ctx, ec.Recover(ctx, r))
10214 ret = graphql.Null
10215 }
10216 }()
10217 fc := &graphql.FieldContext{
10218 Object: "__Type",
10219 Field: field,
10220 Args: nil,
10221 IsMethod: true,
10222 }
10223
10224 ctx = graphql.WithFieldContext(ctx, fc)
10225 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10226 ctx = rctx // use context from middleware stack in children
10227 return obj.PossibleTypes(), nil
10228 })
10229 if err != nil {
10230 ec.Error(ctx, err)
10231 return graphql.Null
10232 }
10233 if resTmp == nil {
10234 return graphql.Null
10235 }
10236 res := resTmp.([]introspection.Type)
10237 fc.Result = res
10238 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10239}
10240
10241func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10242 defer func() {
10243 if r := recover(); r != nil {
10244 ec.Error(ctx, ec.Recover(ctx, r))
10245 ret = graphql.Null
10246 }
10247 }()
10248 fc := &graphql.FieldContext{
10249 Object: "__Type",
10250 Field: field,
10251 Args: nil,
10252 IsMethod: true,
10253 }
10254
10255 ctx = graphql.WithFieldContext(ctx, fc)
10256 rawArgs := field.ArgumentMap(ec.Variables)
10257 args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
10258 if err != nil {
10259 ec.Error(ctx, err)
10260 return graphql.Null
10261 }
10262 fc.Args = args
10263 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10264 ctx = rctx // use context from middleware stack in children
10265 return obj.EnumValues(args["includeDeprecated"].(bool)), nil
10266 })
10267 if err != nil {
10268 ec.Error(ctx, err)
10269 return graphql.Null
10270 }
10271 if resTmp == nil {
10272 return graphql.Null
10273 }
10274 res := resTmp.([]introspection.EnumValue)
10275 fc.Result = res
10276 return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
10277}
10278
10279func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10280 defer func() {
10281 if r := recover(); r != nil {
10282 ec.Error(ctx, ec.Recover(ctx, r))
10283 ret = graphql.Null
10284 }
10285 }()
10286 fc := &graphql.FieldContext{
10287 Object: "__Type",
10288 Field: field,
10289 Args: nil,
10290 IsMethod: true,
10291 }
10292
10293 ctx = graphql.WithFieldContext(ctx, fc)
10294 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10295 ctx = rctx // use context from middleware stack in children
10296 return obj.InputFields(), nil
10297 })
10298 if err != nil {
10299 ec.Error(ctx, err)
10300 return graphql.Null
10301 }
10302 if resTmp == nil {
10303 return graphql.Null
10304 }
10305 res := resTmp.([]introspection.InputValue)
10306 fc.Result = res
10307 return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
10308}
10309
10310func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10311 defer func() {
10312 if r := recover(); r != nil {
10313 ec.Error(ctx, ec.Recover(ctx, r))
10314 ret = graphql.Null
10315 }
10316 }()
10317 fc := &graphql.FieldContext{
10318 Object: "__Type",
10319 Field: field,
10320 Args: nil,
10321 IsMethod: true,
10322 }
10323
10324 ctx = graphql.WithFieldContext(ctx, fc)
10325 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10326 ctx = rctx // use context from middleware stack in children
10327 return obj.OfType(), nil
10328 })
10329 if err != nil {
10330 ec.Error(ctx, err)
10331 return graphql.Null
10332 }
10333 if resTmp == nil {
10334 return graphql.Null
10335 }
10336 res := resTmp.(*introspection.Type)
10337 fc.Result = res
10338 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10339}
10340
10341// endregion **************************** field.gotpl *****************************
10342
10343// region **************************** input.gotpl *****************************
10344
10345func (ec *executionContext) unmarshalInputAddCommentAndCloseBugInput(ctx context.Context, obj interface{}) (models.AddCommentAndCloseBugInput, error) {
10346 var it models.AddCommentAndCloseBugInput
10347 var asMap = obj.(map[string]interface{})
10348
10349 for k, v := range asMap {
10350 switch k {
10351 case "clientMutationId":
10352 var err error
10353 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10354 if err != nil {
10355 return it, err
10356 }
10357 case "repoRef":
10358 var err error
10359 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10360 if err != nil {
10361 return it, err
10362 }
10363 case "prefix":
10364 var err error
10365 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10366 if err != nil {
10367 return it, err
10368 }
10369 case "message":
10370 var err error
10371 it.Message, err = ec.unmarshalNString2string(ctx, v)
10372 if err != nil {
10373 return it, err
10374 }
10375 case "files":
10376 var err error
10377 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
10378 if err != nil {
10379 return it, err
10380 }
10381 }
10382 }
10383
10384 return it, nil
10385}
10386
10387func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
10388 var it models.AddCommentInput
10389 var asMap = obj.(map[string]interface{})
10390
10391 for k, v := range asMap {
10392 switch k {
10393 case "clientMutationId":
10394 var err error
10395 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10396 if err != nil {
10397 return it, err
10398 }
10399 case "repoRef":
10400 var err error
10401 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10402 if err != nil {
10403 return it, err
10404 }
10405 case "prefix":
10406 var err error
10407 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10408 if err != nil {
10409 return it, err
10410 }
10411 case "message":
10412 var err error
10413 it.Message, err = ec.unmarshalNString2string(ctx, v)
10414 if err != nil {
10415 return it, err
10416 }
10417 case "files":
10418 var err error
10419 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
10420 if err != nil {
10421 return it, err
10422 }
10423 }
10424 }
10425
10426 return it, nil
10427}
10428
10429func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
10430 var it models.ChangeLabelInput
10431 var asMap = obj.(map[string]interface{})
10432
10433 for k, v := range asMap {
10434 switch k {
10435 case "clientMutationId":
10436 var err error
10437 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10438 if err != nil {
10439 return it, err
10440 }
10441 case "repoRef":
10442 var err error
10443 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10444 if err != nil {
10445 return it, err
10446 }
10447 case "prefix":
10448 var err error
10449 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10450 if err != nil {
10451 return it, err
10452 }
10453 case "added":
10454 var err error
10455 it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10456 if err != nil {
10457 return it, err
10458 }
10459 case "Removed":
10460 var err error
10461 it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10462 if err != nil {
10463 return it, err
10464 }
10465 }
10466 }
10467
10468 return it, nil
10469}
10470
10471func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
10472 var it models.CloseBugInput
10473 var asMap = obj.(map[string]interface{})
10474
10475 for k, v := range asMap {
10476 switch k {
10477 case "clientMutationId":
10478 var err error
10479 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10480 if err != nil {
10481 return it, err
10482 }
10483 case "repoRef":
10484 var err error
10485 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10486 if err != nil {
10487 return it, err
10488 }
10489 case "prefix":
10490 var err error
10491 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10492 if err != nil {
10493 return it, err
10494 }
10495 }
10496 }
10497
10498 return it, nil
10499}
10500
10501func (ec *executionContext) unmarshalInputEditCommentInput(ctx context.Context, obj interface{}) (models.EditCommentInput, error) {
10502 var it models.EditCommentInput
10503 var asMap = obj.(map[string]interface{})
10504
10505 for k, v := range asMap {
10506 switch k {
10507 case "clientMutationId":
10508 var err error
10509 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10510 if err != nil {
10511 return it, err
10512 }
10513 case "repoRef":
10514 var err error
10515 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10516 if err != nil {
10517 return it, err
10518 }
10519 case "prefix":
10520 var err error
10521 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10522 if err != nil {
10523 return it, err
10524 }
10525 case "target":
10526 var err error
10527 it.Target, err = ec.unmarshalNString2string(ctx, v)
10528 if err != nil {
10529 return it, err
10530 }
10531 case "message":
10532 var err error
10533 it.Message, err = ec.unmarshalNString2string(ctx, v)
10534 if err != nil {
10535 return it, err
10536 }
10537 case "files":
10538 var err error
10539 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
10540 if err != nil {
10541 return it, err
10542 }
10543 }
10544 }
10545
10546 return it, nil
10547}
10548
10549func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
10550 var it models.NewBugInput
10551 var asMap = obj.(map[string]interface{})
10552
10553 for k, v := range asMap {
10554 switch k {
10555 case "clientMutationId":
10556 var err error
10557 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10558 if err != nil {
10559 return it, err
10560 }
10561 case "repoRef":
10562 var err error
10563 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10564 if err != nil {
10565 return it, err
10566 }
10567 case "title":
10568 var err error
10569 it.Title, err = ec.unmarshalNString2string(ctx, v)
10570 if err != nil {
10571 return it, err
10572 }
10573 case "message":
10574 var err error
10575 it.Message, err = ec.unmarshalNString2string(ctx, v)
10576 if err != nil {
10577 return it, err
10578 }
10579 case "files":
10580 var err error
10581 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
10582 if err != nil {
10583 return it, err
10584 }
10585 }
10586 }
10587
10588 return it, nil
10589}
10590
10591func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
10592 var it models.OpenBugInput
10593 var asMap = obj.(map[string]interface{})
10594
10595 for k, v := range asMap {
10596 switch k {
10597 case "clientMutationId":
10598 var err error
10599 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10600 if err != nil {
10601 return it, err
10602 }
10603 case "repoRef":
10604 var err error
10605 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10606 if err != nil {
10607 return it, err
10608 }
10609 case "prefix":
10610 var err error
10611 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10612 if err != nil {
10613 return it, err
10614 }
10615 }
10616 }
10617
10618 return it, nil
10619}
10620
10621func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
10622 var it models.SetTitleInput
10623 var asMap = obj.(map[string]interface{})
10624
10625 for k, v := range asMap {
10626 switch k {
10627 case "clientMutationId":
10628 var err error
10629 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10630 if err != nil {
10631 return it, err
10632 }
10633 case "repoRef":
10634 var err error
10635 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10636 if err != nil {
10637 return it, err
10638 }
10639 case "prefix":
10640 var err error
10641 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10642 if err != nil {
10643 return it, err
10644 }
10645 case "title":
10646 var err error
10647 it.Title, err = ec.unmarshalNString2string(ctx, v)
10648 if err != nil {
10649 return it, err
10650 }
10651 }
10652 }
10653
10654 return it, nil
10655}
10656
10657// endregion **************************** input.gotpl *****************************
10658
10659// region ************************** interface.gotpl ***************************
10660
10661func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj models.Authored) graphql.Marshaler {
10662 switch obj := (obj).(type) {
10663 case nil:
10664 return graphql.Null
10665 case bug.Comment:
10666 return ec._Comment(ctx, sel, &obj)
10667 case *bug.Comment:
10668 if obj == nil {
10669 return graphql.Null
10670 }
10671 return ec._Comment(ctx, sel, obj)
10672 case models.BugWrapper:
10673 if obj == nil {
10674 return graphql.Null
10675 }
10676 return ec._Bug(ctx, sel, obj)
10677 case *bug.CreateOperation:
10678 if obj == nil {
10679 return graphql.Null
10680 }
10681 return ec._CreateOperation(ctx, sel, obj)
10682 case *bug.SetTitleOperation:
10683 if obj == nil {
10684 return graphql.Null
10685 }
10686 return ec._SetTitleOperation(ctx, sel, obj)
10687 case *bug.AddCommentOperation:
10688 if obj == nil {
10689 return graphql.Null
10690 }
10691 return ec._AddCommentOperation(ctx, sel, obj)
10692 case *bug.EditCommentOperation:
10693 if obj == nil {
10694 return graphql.Null
10695 }
10696 return ec._EditCommentOperation(ctx, sel, obj)
10697 case *bug.SetStatusOperation:
10698 if obj == nil {
10699 return graphql.Null
10700 }
10701 return ec._SetStatusOperation(ctx, sel, obj)
10702 case *bug.LabelChangeOperation:
10703 if obj == nil {
10704 return graphql.Null
10705 }
10706 return ec._LabelChangeOperation(ctx, sel, obj)
10707 case *bug.CreateTimelineItem:
10708 if obj == nil {
10709 return graphql.Null
10710 }
10711 return ec._CreateTimelineItem(ctx, sel, obj)
10712 case *bug.AddCommentTimelineItem:
10713 if obj == nil {
10714 return graphql.Null
10715 }
10716 return ec._AddCommentTimelineItem(ctx, sel, obj)
10717 case *bug.LabelChangeTimelineItem:
10718 if obj == nil {
10719 return graphql.Null
10720 }
10721 return ec._LabelChangeTimelineItem(ctx, sel, obj)
10722 case *bug.SetStatusTimelineItem:
10723 if obj == nil {
10724 return graphql.Null
10725 }
10726 return ec._SetStatusTimelineItem(ctx, sel, obj)
10727 case *bug.SetTitleTimelineItem:
10728 if obj == nil {
10729 return graphql.Null
10730 }
10731 return ec._SetTitleTimelineItem(ctx, sel, obj)
10732 default:
10733 panic(fmt.Errorf("unexpected type %T", obj))
10734 }
10735}
10736
10737func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj bug.Operation) graphql.Marshaler {
10738 switch obj := (obj).(type) {
10739 case nil:
10740 return graphql.Null
10741 case *bug.CreateOperation:
10742 if obj == nil {
10743 return graphql.Null
10744 }
10745 return ec._CreateOperation(ctx, sel, obj)
10746 case *bug.SetTitleOperation:
10747 if obj == nil {
10748 return graphql.Null
10749 }
10750 return ec._SetTitleOperation(ctx, sel, obj)
10751 case *bug.AddCommentOperation:
10752 if obj == nil {
10753 return graphql.Null
10754 }
10755 return ec._AddCommentOperation(ctx, sel, obj)
10756 case *bug.EditCommentOperation:
10757 if obj == nil {
10758 return graphql.Null
10759 }
10760 return ec._EditCommentOperation(ctx, sel, obj)
10761 case *bug.SetStatusOperation:
10762 if obj == nil {
10763 return graphql.Null
10764 }
10765 return ec._SetStatusOperation(ctx, sel, obj)
10766 case *bug.LabelChangeOperation:
10767 if obj == nil {
10768 return graphql.Null
10769 }
10770 return ec._LabelChangeOperation(ctx, sel, obj)
10771 default:
10772 panic(fmt.Errorf("unexpected type %T", obj))
10773 }
10774}
10775
10776func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
10777 switch obj := (obj).(type) {
10778 case nil:
10779 return graphql.Null
10780 case *bug.CreateTimelineItem:
10781 if obj == nil {
10782 return graphql.Null
10783 }
10784 return ec._CreateTimelineItem(ctx, sel, obj)
10785 case *bug.AddCommentTimelineItem:
10786 if obj == nil {
10787 return graphql.Null
10788 }
10789 return ec._AddCommentTimelineItem(ctx, sel, obj)
10790 case bug.LabelChangeTimelineItem:
10791 return ec._LabelChangeTimelineItem(ctx, sel, &obj)
10792 case *bug.LabelChangeTimelineItem:
10793 if obj == nil {
10794 return graphql.Null
10795 }
10796 return ec._LabelChangeTimelineItem(ctx, sel, obj)
10797 case bug.SetStatusTimelineItem:
10798 return ec._SetStatusTimelineItem(ctx, sel, &obj)
10799 case *bug.SetStatusTimelineItem:
10800 if obj == nil {
10801 return graphql.Null
10802 }
10803 return ec._SetStatusTimelineItem(ctx, sel, obj)
10804 case bug.SetTitleTimelineItem:
10805 return ec._SetTitleTimelineItem(ctx, sel, &obj)
10806 case *bug.SetTitleTimelineItem:
10807 if obj == nil {
10808 return graphql.Null
10809 }
10810 return ec._SetTitleTimelineItem(ctx, sel, obj)
10811 default:
10812 panic(fmt.Errorf("unexpected type %T", obj))
10813 }
10814}
10815
10816// endregion ************************** interface.gotpl ***************************
10817
10818// region **************************** object.gotpl ****************************
10819
10820var addCommentAndCloseBugPayloadImplementors = []string{"AddCommentAndCloseBugPayload"}
10821
10822func (ec *executionContext) _AddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentAndCloseBugPayload) graphql.Marshaler {
10823 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentAndCloseBugPayloadImplementors)
10824
10825 out := graphql.NewFieldSet(fields)
10826 var invalids uint32
10827 for i, field := range fields {
10828 switch field.Name {
10829 case "__typename":
10830 out.Values[i] = graphql.MarshalString("AddCommentAndCloseBugPayload")
10831 case "clientMutationId":
10832 out.Values[i] = ec._AddCommentAndCloseBugPayload_clientMutationId(ctx, field, obj)
10833 case "bug":
10834 out.Values[i] = ec._AddCommentAndCloseBugPayload_bug(ctx, field, obj)
10835 if out.Values[i] == graphql.Null {
10836 invalids++
10837 }
10838 case "commentOperation":
10839 out.Values[i] = ec._AddCommentAndCloseBugPayload_commentOperation(ctx, field, obj)
10840 if out.Values[i] == graphql.Null {
10841 invalids++
10842 }
10843 case "statusOperation":
10844 out.Values[i] = ec._AddCommentAndCloseBugPayload_statusOperation(ctx, field, obj)
10845 if out.Values[i] == graphql.Null {
10846 invalids++
10847 }
10848 default:
10849 panic("unknown field " + strconv.Quote(field.Name))
10850 }
10851 }
10852 out.Dispatch()
10853 if invalids > 0 {
10854 return graphql.Null
10855 }
10856 return out
10857}
10858
10859var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
10860
10861func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
10862 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
10863
10864 out := graphql.NewFieldSet(fields)
10865 var invalids uint32
10866 for i, field := range fields {
10867 switch field.Name {
10868 case "__typename":
10869 out.Values[i] = graphql.MarshalString("AddCommentOperation")
10870 case "id":
10871 field := field
10872 out.Concurrently(i, func() (res graphql.Marshaler) {
10873 defer func() {
10874 if r := recover(); r != nil {
10875 ec.Error(ctx, ec.Recover(ctx, r))
10876 }
10877 }()
10878 res = ec._AddCommentOperation_id(ctx, field, obj)
10879 if res == graphql.Null {
10880 atomic.AddUint32(&invalids, 1)
10881 }
10882 return res
10883 })
10884 case "author":
10885 field := field
10886 out.Concurrently(i, func() (res graphql.Marshaler) {
10887 defer func() {
10888 if r := recover(); r != nil {
10889 ec.Error(ctx, ec.Recover(ctx, r))
10890 }
10891 }()
10892 res = ec._AddCommentOperation_author(ctx, field, obj)
10893 if res == graphql.Null {
10894 atomic.AddUint32(&invalids, 1)
10895 }
10896 return res
10897 })
10898 case "date":
10899 field := field
10900 out.Concurrently(i, func() (res graphql.Marshaler) {
10901 defer func() {
10902 if r := recover(); r != nil {
10903 ec.Error(ctx, ec.Recover(ctx, r))
10904 }
10905 }()
10906 res = ec._AddCommentOperation_date(ctx, field, obj)
10907 if res == graphql.Null {
10908 atomic.AddUint32(&invalids, 1)
10909 }
10910 return res
10911 })
10912 case "message":
10913 out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
10914 if out.Values[i] == graphql.Null {
10915 atomic.AddUint32(&invalids, 1)
10916 }
10917 case "files":
10918 out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
10919 if out.Values[i] == graphql.Null {
10920 atomic.AddUint32(&invalids, 1)
10921 }
10922 default:
10923 panic("unknown field " + strconv.Quote(field.Name))
10924 }
10925 }
10926 out.Dispatch()
10927 if invalids > 0 {
10928 return graphql.Null
10929 }
10930 return out
10931}
10932
10933var addCommentPayloadImplementors = []string{"AddCommentPayload"}
10934
10935func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
10936 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
10937
10938 out := graphql.NewFieldSet(fields)
10939 var invalids uint32
10940 for i, field := range fields {
10941 switch field.Name {
10942 case "__typename":
10943 out.Values[i] = graphql.MarshalString("AddCommentPayload")
10944 case "clientMutationId":
10945 out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
10946 case "bug":
10947 out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
10948 if out.Values[i] == graphql.Null {
10949 invalids++
10950 }
10951 case "operation":
10952 out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
10953 if out.Values[i] == graphql.Null {
10954 invalids++
10955 }
10956 default:
10957 panic("unknown field " + strconv.Quote(field.Name))
10958 }
10959 }
10960 out.Dispatch()
10961 if invalids > 0 {
10962 return graphql.Null
10963 }
10964 return out
10965}
10966
10967var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
10968
10969func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
10970 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
10971
10972 out := graphql.NewFieldSet(fields)
10973 var invalids uint32
10974 for i, field := range fields {
10975 switch field.Name {
10976 case "__typename":
10977 out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
10978 case "id":
10979 field := field
10980 out.Concurrently(i, func() (res graphql.Marshaler) {
10981 defer func() {
10982 if r := recover(); r != nil {
10983 ec.Error(ctx, ec.Recover(ctx, r))
10984 }
10985 }()
10986 res = ec._AddCommentTimelineItem_id(ctx, field, obj)
10987 if res == graphql.Null {
10988 atomic.AddUint32(&invalids, 1)
10989 }
10990 return res
10991 })
10992 case "author":
10993 field := field
10994 out.Concurrently(i, func() (res graphql.Marshaler) {
10995 defer func() {
10996 if r := recover(); r != nil {
10997 ec.Error(ctx, ec.Recover(ctx, r))
10998 }
10999 }()
11000 res = ec._AddCommentTimelineItem_author(ctx, field, obj)
11001 if res == graphql.Null {
11002 atomic.AddUint32(&invalids, 1)
11003 }
11004 return res
11005 })
11006 case "message":
11007 out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
11008 if out.Values[i] == graphql.Null {
11009 atomic.AddUint32(&invalids, 1)
11010 }
11011 case "messageIsEmpty":
11012 out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
11013 if out.Values[i] == graphql.Null {
11014 atomic.AddUint32(&invalids, 1)
11015 }
11016 case "files":
11017 out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
11018 if out.Values[i] == graphql.Null {
11019 atomic.AddUint32(&invalids, 1)
11020 }
11021 case "createdAt":
11022 field := field
11023 out.Concurrently(i, func() (res graphql.Marshaler) {
11024 defer func() {
11025 if r := recover(); r != nil {
11026 ec.Error(ctx, ec.Recover(ctx, r))
11027 }
11028 }()
11029 res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
11030 if res == graphql.Null {
11031 atomic.AddUint32(&invalids, 1)
11032 }
11033 return res
11034 })
11035 case "lastEdit":
11036 field := field
11037 out.Concurrently(i, func() (res graphql.Marshaler) {
11038 defer func() {
11039 if r := recover(); r != nil {
11040 ec.Error(ctx, ec.Recover(ctx, r))
11041 }
11042 }()
11043 res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
11044 if res == graphql.Null {
11045 atomic.AddUint32(&invalids, 1)
11046 }
11047 return res
11048 })
11049 case "edited":
11050 out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
11051 if out.Values[i] == graphql.Null {
11052 atomic.AddUint32(&invalids, 1)
11053 }
11054 case "history":
11055 out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
11056 if out.Values[i] == graphql.Null {
11057 atomic.AddUint32(&invalids, 1)
11058 }
11059 default:
11060 panic("unknown field " + strconv.Quote(field.Name))
11061 }
11062 }
11063 out.Dispatch()
11064 if invalids > 0 {
11065 return graphql.Null
11066 }
11067 return out
11068}
11069
11070var bugImplementors = []string{"Bug", "Authored"}
11071
11072func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
11073 fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
11074
11075 out := graphql.NewFieldSet(fields)
11076 var invalids uint32
11077 for i, field := range fields {
11078 switch field.Name {
11079 case "__typename":
11080 out.Values[i] = graphql.MarshalString("Bug")
11081 case "id":
11082 field := field
11083 out.Concurrently(i, func() (res graphql.Marshaler) {
11084 defer func() {
11085 if r := recover(); r != nil {
11086 ec.Error(ctx, ec.Recover(ctx, r))
11087 }
11088 }()
11089 res = ec._Bug_id(ctx, field, obj)
11090 if res == graphql.Null {
11091 atomic.AddUint32(&invalids, 1)
11092 }
11093 return res
11094 })
11095 case "humanId":
11096 field := field
11097 out.Concurrently(i, func() (res graphql.Marshaler) {
11098 defer func() {
11099 if r := recover(); r != nil {
11100 ec.Error(ctx, ec.Recover(ctx, r))
11101 }
11102 }()
11103 res = ec._Bug_humanId(ctx, field, obj)
11104 if res == graphql.Null {
11105 atomic.AddUint32(&invalids, 1)
11106 }
11107 return res
11108 })
11109 case "status":
11110 field := field
11111 out.Concurrently(i, func() (res graphql.Marshaler) {
11112 defer func() {
11113 if r := recover(); r != nil {
11114 ec.Error(ctx, ec.Recover(ctx, r))
11115 }
11116 }()
11117 res = ec._Bug_status(ctx, field, obj)
11118 if res == graphql.Null {
11119 atomic.AddUint32(&invalids, 1)
11120 }
11121 return res
11122 })
11123 case "title":
11124 out.Values[i] = ec._Bug_title(ctx, field, obj)
11125 if out.Values[i] == graphql.Null {
11126 atomic.AddUint32(&invalids, 1)
11127 }
11128 case "labels":
11129 out.Values[i] = ec._Bug_labels(ctx, field, obj)
11130 if out.Values[i] == graphql.Null {
11131 atomic.AddUint32(&invalids, 1)
11132 }
11133 case "author":
11134 out.Values[i] = ec._Bug_author(ctx, field, obj)
11135 if out.Values[i] == graphql.Null {
11136 atomic.AddUint32(&invalids, 1)
11137 }
11138 case "createdAt":
11139 out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
11140 if out.Values[i] == graphql.Null {
11141 atomic.AddUint32(&invalids, 1)
11142 }
11143 case "lastEdit":
11144 out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
11145 if out.Values[i] == graphql.Null {
11146 atomic.AddUint32(&invalids, 1)
11147 }
11148 case "actors":
11149 field := field
11150 out.Concurrently(i, func() (res graphql.Marshaler) {
11151 defer func() {
11152 if r := recover(); r != nil {
11153 ec.Error(ctx, ec.Recover(ctx, r))
11154 }
11155 }()
11156 res = ec._Bug_actors(ctx, field, obj)
11157 if res == graphql.Null {
11158 atomic.AddUint32(&invalids, 1)
11159 }
11160 return res
11161 })
11162 case "participants":
11163 field := field
11164 out.Concurrently(i, func() (res graphql.Marshaler) {
11165 defer func() {
11166 if r := recover(); r != nil {
11167 ec.Error(ctx, ec.Recover(ctx, r))
11168 }
11169 }()
11170 res = ec._Bug_participants(ctx, field, obj)
11171 if res == graphql.Null {
11172 atomic.AddUint32(&invalids, 1)
11173 }
11174 return res
11175 })
11176 case "comments":
11177 field := field
11178 out.Concurrently(i, func() (res graphql.Marshaler) {
11179 defer func() {
11180 if r := recover(); r != nil {
11181 ec.Error(ctx, ec.Recover(ctx, r))
11182 }
11183 }()
11184 res = ec._Bug_comments(ctx, field, obj)
11185 if res == graphql.Null {
11186 atomic.AddUint32(&invalids, 1)
11187 }
11188 return res
11189 })
11190 case "timeline":
11191 field := field
11192 out.Concurrently(i, func() (res graphql.Marshaler) {
11193 defer func() {
11194 if r := recover(); r != nil {
11195 ec.Error(ctx, ec.Recover(ctx, r))
11196 }
11197 }()
11198 res = ec._Bug_timeline(ctx, field, obj)
11199 if res == graphql.Null {
11200 atomic.AddUint32(&invalids, 1)
11201 }
11202 return res
11203 })
11204 case "operations":
11205 field := field
11206 out.Concurrently(i, func() (res graphql.Marshaler) {
11207 defer func() {
11208 if r := recover(); r != nil {
11209 ec.Error(ctx, ec.Recover(ctx, r))
11210 }
11211 }()
11212 res = ec._Bug_operations(ctx, field, obj)
11213 if res == graphql.Null {
11214 atomic.AddUint32(&invalids, 1)
11215 }
11216 return res
11217 })
11218 default:
11219 panic("unknown field " + strconv.Quote(field.Name))
11220 }
11221 }
11222 out.Dispatch()
11223 if invalids > 0 {
11224 return graphql.Null
11225 }
11226 return out
11227}
11228
11229var bugConnectionImplementors = []string{"BugConnection"}
11230
11231func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
11232 fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
11233
11234 out := graphql.NewFieldSet(fields)
11235 var invalids uint32
11236 for i, field := range fields {
11237 switch field.Name {
11238 case "__typename":
11239 out.Values[i] = graphql.MarshalString("BugConnection")
11240 case "edges":
11241 out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
11242 if out.Values[i] == graphql.Null {
11243 invalids++
11244 }
11245 case "nodes":
11246 out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
11247 if out.Values[i] == graphql.Null {
11248 invalids++
11249 }
11250 case "pageInfo":
11251 out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
11252 if out.Values[i] == graphql.Null {
11253 invalids++
11254 }
11255 case "totalCount":
11256 out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
11257 if out.Values[i] == graphql.Null {
11258 invalids++
11259 }
11260 default:
11261 panic("unknown field " + strconv.Quote(field.Name))
11262 }
11263 }
11264 out.Dispatch()
11265 if invalids > 0 {
11266 return graphql.Null
11267 }
11268 return out
11269}
11270
11271var bugEdgeImplementors = []string{"BugEdge"}
11272
11273func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
11274 fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
11275
11276 out := graphql.NewFieldSet(fields)
11277 var invalids uint32
11278 for i, field := range fields {
11279 switch field.Name {
11280 case "__typename":
11281 out.Values[i] = graphql.MarshalString("BugEdge")
11282 case "cursor":
11283 out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
11284 if out.Values[i] == graphql.Null {
11285 invalids++
11286 }
11287 case "node":
11288 out.Values[i] = ec._BugEdge_node(ctx, field, obj)
11289 if out.Values[i] == graphql.Null {
11290 invalids++
11291 }
11292 default:
11293 panic("unknown field " + strconv.Quote(field.Name))
11294 }
11295 }
11296 out.Dispatch()
11297 if invalids > 0 {
11298 return graphql.Null
11299 }
11300 return out
11301}
11302
11303var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
11304
11305func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
11306 fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
11307
11308 out := graphql.NewFieldSet(fields)
11309 var invalids uint32
11310 for i, field := range fields {
11311 switch field.Name {
11312 case "__typename":
11313 out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
11314 case "clientMutationId":
11315 out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
11316 case "bug":
11317 out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
11318 if out.Values[i] == graphql.Null {
11319 invalids++
11320 }
11321 case "operation":
11322 out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
11323 if out.Values[i] == graphql.Null {
11324 invalids++
11325 }
11326 case "results":
11327 out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
11328 if out.Values[i] == graphql.Null {
11329 invalids++
11330 }
11331 default:
11332 panic("unknown field " + strconv.Quote(field.Name))
11333 }
11334 }
11335 out.Dispatch()
11336 if invalids > 0 {
11337 return graphql.Null
11338 }
11339 return out
11340}
11341
11342var closeBugPayloadImplementors = []string{"CloseBugPayload"}
11343
11344func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
11345 fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
11346
11347 out := graphql.NewFieldSet(fields)
11348 var invalids uint32
11349 for i, field := range fields {
11350 switch field.Name {
11351 case "__typename":
11352 out.Values[i] = graphql.MarshalString("CloseBugPayload")
11353 case "clientMutationId":
11354 out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
11355 case "bug":
11356 out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
11357 if out.Values[i] == graphql.Null {
11358 invalids++
11359 }
11360 case "operation":
11361 out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
11362 if out.Values[i] == graphql.Null {
11363 invalids++
11364 }
11365 default:
11366 panic("unknown field " + strconv.Quote(field.Name))
11367 }
11368 }
11369 out.Dispatch()
11370 if invalids > 0 {
11371 return graphql.Null
11372 }
11373 return out
11374}
11375
11376var colorImplementors = []string{"Color"}
11377
11378func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
11379 fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
11380
11381 out := graphql.NewFieldSet(fields)
11382 var invalids uint32
11383 for i, field := range fields {
11384 switch field.Name {
11385 case "__typename":
11386 out.Values[i] = graphql.MarshalString("Color")
11387 case "R":
11388 field := field
11389 out.Concurrently(i, func() (res graphql.Marshaler) {
11390 defer func() {
11391 if r := recover(); r != nil {
11392 ec.Error(ctx, ec.Recover(ctx, r))
11393 }
11394 }()
11395 res = ec._Color_R(ctx, field, obj)
11396 if res == graphql.Null {
11397 atomic.AddUint32(&invalids, 1)
11398 }
11399 return res
11400 })
11401 case "G":
11402 field := field
11403 out.Concurrently(i, func() (res graphql.Marshaler) {
11404 defer func() {
11405 if r := recover(); r != nil {
11406 ec.Error(ctx, ec.Recover(ctx, r))
11407 }
11408 }()
11409 res = ec._Color_G(ctx, field, obj)
11410 if res == graphql.Null {
11411 atomic.AddUint32(&invalids, 1)
11412 }
11413 return res
11414 })
11415 case "B":
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._Color_B(ctx, field, obj)
11424 if res == graphql.Null {
11425 atomic.AddUint32(&invalids, 1)
11426 }
11427 return res
11428 })
11429 default:
11430 panic("unknown field " + strconv.Quote(field.Name))
11431 }
11432 }
11433 out.Dispatch()
11434 if invalids > 0 {
11435 return graphql.Null
11436 }
11437 return out
11438}
11439
11440var commentImplementors = []string{"Comment", "Authored"}
11441
11442func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
11443 fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
11444
11445 out := graphql.NewFieldSet(fields)
11446 var invalids uint32
11447 for i, field := range fields {
11448 switch field.Name {
11449 case "__typename":
11450 out.Values[i] = graphql.MarshalString("Comment")
11451 case "author":
11452 field := field
11453 out.Concurrently(i, func() (res graphql.Marshaler) {
11454 defer func() {
11455 if r := recover(); r != nil {
11456 ec.Error(ctx, ec.Recover(ctx, r))
11457 }
11458 }()
11459 res = ec._Comment_author(ctx, field, obj)
11460 if res == graphql.Null {
11461 atomic.AddUint32(&invalids, 1)
11462 }
11463 return res
11464 })
11465 case "message":
11466 out.Values[i] = ec._Comment_message(ctx, field, obj)
11467 if out.Values[i] == graphql.Null {
11468 atomic.AddUint32(&invalids, 1)
11469 }
11470 case "files":
11471 out.Values[i] = ec._Comment_files(ctx, field, obj)
11472 if out.Values[i] == graphql.Null {
11473 atomic.AddUint32(&invalids, 1)
11474 }
11475 default:
11476 panic("unknown field " + strconv.Quote(field.Name))
11477 }
11478 }
11479 out.Dispatch()
11480 if invalids > 0 {
11481 return graphql.Null
11482 }
11483 return out
11484}
11485
11486var commentConnectionImplementors = []string{"CommentConnection"}
11487
11488func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
11489 fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
11490
11491 out := graphql.NewFieldSet(fields)
11492 var invalids uint32
11493 for i, field := range fields {
11494 switch field.Name {
11495 case "__typename":
11496 out.Values[i] = graphql.MarshalString("CommentConnection")
11497 case "edges":
11498 out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
11499 if out.Values[i] == graphql.Null {
11500 invalids++
11501 }
11502 case "nodes":
11503 out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
11504 if out.Values[i] == graphql.Null {
11505 invalids++
11506 }
11507 case "pageInfo":
11508 out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
11509 if out.Values[i] == graphql.Null {
11510 invalids++
11511 }
11512 case "totalCount":
11513 out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
11514 if out.Values[i] == graphql.Null {
11515 invalids++
11516 }
11517 default:
11518 panic("unknown field " + strconv.Quote(field.Name))
11519 }
11520 }
11521 out.Dispatch()
11522 if invalids > 0 {
11523 return graphql.Null
11524 }
11525 return out
11526}
11527
11528var commentEdgeImplementors = []string{"CommentEdge"}
11529
11530func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
11531 fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
11532
11533 out := graphql.NewFieldSet(fields)
11534 var invalids uint32
11535 for i, field := range fields {
11536 switch field.Name {
11537 case "__typename":
11538 out.Values[i] = graphql.MarshalString("CommentEdge")
11539 case "cursor":
11540 out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
11541 if out.Values[i] == graphql.Null {
11542 invalids++
11543 }
11544 case "node":
11545 out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
11546 if out.Values[i] == graphql.Null {
11547 invalids++
11548 }
11549 default:
11550 panic("unknown field " + strconv.Quote(field.Name))
11551 }
11552 }
11553 out.Dispatch()
11554 if invalids > 0 {
11555 return graphql.Null
11556 }
11557 return out
11558}
11559
11560var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
11561
11562func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
11563 fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
11564
11565 out := graphql.NewFieldSet(fields)
11566 var invalids uint32
11567 for i, field := range fields {
11568 switch field.Name {
11569 case "__typename":
11570 out.Values[i] = graphql.MarshalString("CommentHistoryStep")
11571 case "message":
11572 out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
11573 if out.Values[i] == graphql.Null {
11574 atomic.AddUint32(&invalids, 1)
11575 }
11576 case "date":
11577 field := field
11578 out.Concurrently(i, func() (res graphql.Marshaler) {
11579 defer func() {
11580 if r := recover(); r != nil {
11581 ec.Error(ctx, ec.Recover(ctx, r))
11582 }
11583 }()
11584 res = ec._CommentHistoryStep_date(ctx, field, obj)
11585 if res == graphql.Null {
11586 atomic.AddUint32(&invalids, 1)
11587 }
11588 return res
11589 })
11590 default:
11591 panic("unknown field " + strconv.Quote(field.Name))
11592 }
11593 }
11594 out.Dispatch()
11595 if invalids > 0 {
11596 return graphql.Null
11597 }
11598 return out
11599}
11600
11601var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
11602
11603func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
11604 fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
11605
11606 out := graphql.NewFieldSet(fields)
11607 var invalids uint32
11608 for i, field := range fields {
11609 switch field.Name {
11610 case "__typename":
11611 out.Values[i] = graphql.MarshalString("CreateOperation")
11612 case "id":
11613 field := field
11614 out.Concurrently(i, func() (res graphql.Marshaler) {
11615 defer func() {
11616 if r := recover(); r != nil {
11617 ec.Error(ctx, ec.Recover(ctx, r))
11618 }
11619 }()
11620 res = ec._CreateOperation_id(ctx, field, obj)
11621 if res == graphql.Null {
11622 atomic.AddUint32(&invalids, 1)
11623 }
11624 return res
11625 })
11626 case "author":
11627 field := field
11628 out.Concurrently(i, func() (res graphql.Marshaler) {
11629 defer func() {
11630 if r := recover(); r != nil {
11631 ec.Error(ctx, ec.Recover(ctx, r))
11632 }
11633 }()
11634 res = ec._CreateOperation_author(ctx, field, obj)
11635 if res == graphql.Null {
11636 atomic.AddUint32(&invalids, 1)
11637 }
11638 return res
11639 })
11640 case "date":
11641 field := field
11642 out.Concurrently(i, func() (res graphql.Marshaler) {
11643 defer func() {
11644 if r := recover(); r != nil {
11645 ec.Error(ctx, ec.Recover(ctx, r))
11646 }
11647 }()
11648 res = ec._CreateOperation_date(ctx, field, obj)
11649 if res == graphql.Null {
11650 atomic.AddUint32(&invalids, 1)
11651 }
11652 return res
11653 })
11654 case "title":
11655 out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
11656 if out.Values[i] == graphql.Null {
11657 atomic.AddUint32(&invalids, 1)
11658 }
11659 case "message":
11660 out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
11661 if out.Values[i] == graphql.Null {
11662 atomic.AddUint32(&invalids, 1)
11663 }
11664 case "files":
11665 out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
11666 if out.Values[i] == graphql.Null {
11667 atomic.AddUint32(&invalids, 1)
11668 }
11669 default:
11670 panic("unknown field " + strconv.Quote(field.Name))
11671 }
11672 }
11673 out.Dispatch()
11674 if invalids > 0 {
11675 return graphql.Null
11676 }
11677 return out
11678}
11679
11680var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
11681
11682func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
11683 fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
11684
11685 out := graphql.NewFieldSet(fields)
11686 var invalids uint32
11687 for i, field := range fields {
11688 switch field.Name {
11689 case "__typename":
11690 out.Values[i] = graphql.MarshalString("CreateTimelineItem")
11691 case "id":
11692 field := field
11693 out.Concurrently(i, func() (res graphql.Marshaler) {
11694 defer func() {
11695 if r := recover(); r != nil {
11696 ec.Error(ctx, ec.Recover(ctx, r))
11697 }
11698 }()
11699 res = ec._CreateTimelineItem_id(ctx, field, obj)
11700 if res == graphql.Null {
11701 atomic.AddUint32(&invalids, 1)
11702 }
11703 return res
11704 })
11705 case "author":
11706 field := field
11707 out.Concurrently(i, func() (res graphql.Marshaler) {
11708 defer func() {
11709 if r := recover(); r != nil {
11710 ec.Error(ctx, ec.Recover(ctx, r))
11711 }
11712 }()
11713 res = ec._CreateTimelineItem_author(ctx, field, obj)
11714 if res == graphql.Null {
11715 atomic.AddUint32(&invalids, 1)
11716 }
11717 return res
11718 })
11719 case "message":
11720 out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
11721 if out.Values[i] == graphql.Null {
11722 atomic.AddUint32(&invalids, 1)
11723 }
11724 case "messageIsEmpty":
11725 out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
11726 if out.Values[i] == graphql.Null {
11727 atomic.AddUint32(&invalids, 1)
11728 }
11729 case "files":
11730 out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
11731 if out.Values[i] == graphql.Null {
11732 atomic.AddUint32(&invalids, 1)
11733 }
11734 case "createdAt":
11735 field := field
11736 out.Concurrently(i, func() (res graphql.Marshaler) {
11737 defer func() {
11738 if r := recover(); r != nil {
11739 ec.Error(ctx, ec.Recover(ctx, r))
11740 }
11741 }()
11742 res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
11743 if res == graphql.Null {
11744 atomic.AddUint32(&invalids, 1)
11745 }
11746 return res
11747 })
11748 case "lastEdit":
11749 field := field
11750 out.Concurrently(i, func() (res graphql.Marshaler) {
11751 defer func() {
11752 if r := recover(); r != nil {
11753 ec.Error(ctx, ec.Recover(ctx, r))
11754 }
11755 }()
11756 res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
11757 if res == graphql.Null {
11758 atomic.AddUint32(&invalids, 1)
11759 }
11760 return res
11761 })
11762 case "edited":
11763 out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
11764 if out.Values[i] == graphql.Null {
11765 atomic.AddUint32(&invalids, 1)
11766 }
11767 case "history":
11768 out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
11769 if out.Values[i] == graphql.Null {
11770 atomic.AddUint32(&invalids, 1)
11771 }
11772 default:
11773 panic("unknown field " + strconv.Quote(field.Name))
11774 }
11775 }
11776 out.Dispatch()
11777 if invalids > 0 {
11778 return graphql.Null
11779 }
11780 return out
11781}
11782
11783var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
11784
11785func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
11786 fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
11787
11788 out := graphql.NewFieldSet(fields)
11789 var invalids uint32
11790 for i, field := range fields {
11791 switch field.Name {
11792 case "__typename":
11793 out.Values[i] = graphql.MarshalString("EditCommentOperation")
11794 case "id":
11795 field := field
11796 out.Concurrently(i, func() (res graphql.Marshaler) {
11797 defer func() {
11798 if r := recover(); r != nil {
11799 ec.Error(ctx, ec.Recover(ctx, r))
11800 }
11801 }()
11802 res = ec._EditCommentOperation_id(ctx, field, obj)
11803 if res == graphql.Null {
11804 atomic.AddUint32(&invalids, 1)
11805 }
11806 return res
11807 })
11808 case "author":
11809 field := field
11810 out.Concurrently(i, func() (res graphql.Marshaler) {
11811 defer func() {
11812 if r := recover(); r != nil {
11813 ec.Error(ctx, ec.Recover(ctx, r))
11814 }
11815 }()
11816 res = ec._EditCommentOperation_author(ctx, field, obj)
11817 if res == graphql.Null {
11818 atomic.AddUint32(&invalids, 1)
11819 }
11820 return res
11821 })
11822 case "date":
11823 field := field
11824 out.Concurrently(i, func() (res graphql.Marshaler) {
11825 defer func() {
11826 if r := recover(); r != nil {
11827 ec.Error(ctx, ec.Recover(ctx, r))
11828 }
11829 }()
11830 res = ec._EditCommentOperation_date(ctx, field, obj)
11831 if res == graphql.Null {
11832 atomic.AddUint32(&invalids, 1)
11833 }
11834 return res
11835 })
11836 case "target":
11837 field := field
11838 out.Concurrently(i, func() (res graphql.Marshaler) {
11839 defer func() {
11840 if r := recover(); r != nil {
11841 ec.Error(ctx, ec.Recover(ctx, r))
11842 }
11843 }()
11844 res = ec._EditCommentOperation_target(ctx, field, obj)
11845 if res == graphql.Null {
11846 atomic.AddUint32(&invalids, 1)
11847 }
11848 return res
11849 })
11850 case "message":
11851 out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
11852 if out.Values[i] == graphql.Null {
11853 atomic.AddUint32(&invalids, 1)
11854 }
11855 case "files":
11856 out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
11857 if out.Values[i] == graphql.Null {
11858 atomic.AddUint32(&invalids, 1)
11859 }
11860 default:
11861 panic("unknown field " + strconv.Quote(field.Name))
11862 }
11863 }
11864 out.Dispatch()
11865 if invalids > 0 {
11866 return graphql.Null
11867 }
11868 return out
11869}
11870
11871var editCommentPayloadImplementors = []string{"EditCommentPayload"}
11872
11873func (ec *executionContext) _EditCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.EditCommentPayload) graphql.Marshaler {
11874 fields := graphql.CollectFields(ec.OperationContext, sel, editCommentPayloadImplementors)
11875
11876 out := graphql.NewFieldSet(fields)
11877 var invalids uint32
11878 for i, field := range fields {
11879 switch field.Name {
11880 case "__typename":
11881 out.Values[i] = graphql.MarshalString("EditCommentPayload")
11882 case "clientMutationId":
11883 out.Values[i] = ec._EditCommentPayload_clientMutationId(ctx, field, obj)
11884 case "bug":
11885 out.Values[i] = ec._EditCommentPayload_bug(ctx, field, obj)
11886 if out.Values[i] == graphql.Null {
11887 invalids++
11888 }
11889 case "operation":
11890 out.Values[i] = ec._EditCommentPayload_operation(ctx, field, obj)
11891 if out.Values[i] == graphql.Null {
11892 invalids++
11893 }
11894 default:
11895 panic("unknown field " + strconv.Quote(field.Name))
11896 }
11897 }
11898 out.Dispatch()
11899 if invalids > 0 {
11900 return graphql.Null
11901 }
11902 return out
11903}
11904
11905var identityImplementors = []string{"Identity"}
11906
11907func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj models.IdentityWrapper) graphql.Marshaler {
11908 fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
11909
11910 out := graphql.NewFieldSet(fields)
11911 var invalids uint32
11912 for i, field := range fields {
11913 switch field.Name {
11914 case "__typename":
11915 out.Values[i] = graphql.MarshalString("Identity")
11916 case "id":
11917 field := field
11918 out.Concurrently(i, func() (res graphql.Marshaler) {
11919 defer func() {
11920 if r := recover(); r != nil {
11921 ec.Error(ctx, ec.Recover(ctx, r))
11922 }
11923 }()
11924 res = ec._Identity_id(ctx, field, obj)
11925 if res == graphql.Null {
11926 atomic.AddUint32(&invalids, 1)
11927 }
11928 return res
11929 })
11930 case "humanId":
11931 field := field
11932 out.Concurrently(i, func() (res graphql.Marshaler) {
11933 defer func() {
11934 if r := recover(); r != nil {
11935 ec.Error(ctx, ec.Recover(ctx, r))
11936 }
11937 }()
11938 res = ec._Identity_humanId(ctx, field, obj)
11939 if res == graphql.Null {
11940 atomic.AddUint32(&invalids, 1)
11941 }
11942 return res
11943 })
11944 case "name":
11945 out.Values[i] = ec._Identity_name(ctx, field, obj)
11946 case "email":
11947 out.Values[i] = ec._Identity_email(ctx, field, obj)
11948 case "login":
11949 out.Values[i] = ec._Identity_login(ctx, field, obj)
11950 case "displayName":
11951 out.Values[i] = ec._Identity_displayName(ctx, field, obj)
11952 if out.Values[i] == graphql.Null {
11953 atomic.AddUint32(&invalids, 1)
11954 }
11955 case "avatarUrl":
11956 out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
11957 case "isProtected":
11958 out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
11959 if out.Values[i] == graphql.Null {
11960 atomic.AddUint32(&invalids, 1)
11961 }
11962 default:
11963 panic("unknown field " + strconv.Quote(field.Name))
11964 }
11965 }
11966 out.Dispatch()
11967 if invalids > 0 {
11968 return graphql.Null
11969 }
11970 return out
11971}
11972
11973var identityConnectionImplementors = []string{"IdentityConnection"}
11974
11975func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
11976 fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
11977
11978 out := graphql.NewFieldSet(fields)
11979 var invalids uint32
11980 for i, field := range fields {
11981 switch field.Name {
11982 case "__typename":
11983 out.Values[i] = graphql.MarshalString("IdentityConnection")
11984 case "edges":
11985 out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
11986 if out.Values[i] == graphql.Null {
11987 invalids++
11988 }
11989 case "nodes":
11990 out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
11991 if out.Values[i] == graphql.Null {
11992 invalids++
11993 }
11994 case "pageInfo":
11995 out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
11996 if out.Values[i] == graphql.Null {
11997 invalids++
11998 }
11999 case "totalCount":
12000 out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
12001 if out.Values[i] == graphql.Null {
12002 invalids++
12003 }
12004 default:
12005 panic("unknown field " + strconv.Quote(field.Name))
12006 }
12007 }
12008 out.Dispatch()
12009 if invalids > 0 {
12010 return graphql.Null
12011 }
12012 return out
12013}
12014
12015var identityEdgeImplementors = []string{"IdentityEdge"}
12016
12017func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
12018 fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
12019
12020 out := graphql.NewFieldSet(fields)
12021 var invalids uint32
12022 for i, field := range fields {
12023 switch field.Name {
12024 case "__typename":
12025 out.Values[i] = graphql.MarshalString("IdentityEdge")
12026 case "cursor":
12027 out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
12028 if out.Values[i] == graphql.Null {
12029 invalids++
12030 }
12031 case "node":
12032 out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
12033 if out.Values[i] == graphql.Null {
12034 invalids++
12035 }
12036 default:
12037 panic("unknown field " + strconv.Quote(field.Name))
12038 }
12039 }
12040 out.Dispatch()
12041 if invalids > 0 {
12042 return graphql.Null
12043 }
12044 return out
12045}
12046
12047var labelImplementors = []string{"Label"}
12048
12049func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
12050 fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
12051
12052 out := graphql.NewFieldSet(fields)
12053 var invalids uint32
12054 for i, field := range fields {
12055 switch field.Name {
12056 case "__typename":
12057 out.Values[i] = graphql.MarshalString("Label")
12058 case "name":
12059 field := field
12060 out.Concurrently(i, func() (res graphql.Marshaler) {
12061 defer func() {
12062 if r := recover(); r != nil {
12063 ec.Error(ctx, ec.Recover(ctx, r))
12064 }
12065 }()
12066 res = ec._Label_name(ctx, field, obj)
12067 if res == graphql.Null {
12068 atomic.AddUint32(&invalids, 1)
12069 }
12070 return res
12071 })
12072 case "color":
12073 field := field
12074 out.Concurrently(i, func() (res graphql.Marshaler) {
12075 defer func() {
12076 if r := recover(); r != nil {
12077 ec.Error(ctx, ec.Recover(ctx, r))
12078 }
12079 }()
12080 res = ec._Label_color(ctx, field, obj)
12081 if res == graphql.Null {
12082 atomic.AddUint32(&invalids, 1)
12083 }
12084 return res
12085 })
12086 default:
12087 panic("unknown field " + strconv.Quote(field.Name))
12088 }
12089 }
12090 out.Dispatch()
12091 if invalids > 0 {
12092 return graphql.Null
12093 }
12094 return out
12095}
12096
12097var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
12098
12099func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
12100 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
12101
12102 out := graphql.NewFieldSet(fields)
12103 var invalids uint32
12104 for i, field := range fields {
12105 switch field.Name {
12106 case "__typename":
12107 out.Values[i] = graphql.MarshalString("LabelChangeOperation")
12108 case "id":
12109 field := field
12110 out.Concurrently(i, func() (res graphql.Marshaler) {
12111 defer func() {
12112 if r := recover(); r != nil {
12113 ec.Error(ctx, ec.Recover(ctx, r))
12114 }
12115 }()
12116 res = ec._LabelChangeOperation_id(ctx, field, obj)
12117 if res == graphql.Null {
12118 atomic.AddUint32(&invalids, 1)
12119 }
12120 return res
12121 })
12122 case "author":
12123 field := field
12124 out.Concurrently(i, func() (res graphql.Marshaler) {
12125 defer func() {
12126 if r := recover(); r != nil {
12127 ec.Error(ctx, ec.Recover(ctx, r))
12128 }
12129 }()
12130 res = ec._LabelChangeOperation_author(ctx, field, obj)
12131 if res == graphql.Null {
12132 atomic.AddUint32(&invalids, 1)
12133 }
12134 return res
12135 })
12136 case "date":
12137 field := field
12138 out.Concurrently(i, func() (res graphql.Marshaler) {
12139 defer func() {
12140 if r := recover(); r != nil {
12141 ec.Error(ctx, ec.Recover(ctx, r))
12142 }
12143 }()
12144 res = ec._LabelChangeOperation_date(ctx, field, obj)
12145 if res == graphql.Null {
12146 atomic.AddUint32(&invalids, 1)
12147 }
12148 return res
12149 })
12150 case "added":
12151 out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
12152 if out.Values[i] == graphql.Null {
12153 atomic.AddUint32(&invalids, 1)
12154 }
12155 case "removed":
12156 out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
12157 if out.Values[i] == graphql.Null {
12158 atomic.AddUint32(&invalids, 1)
12159 }
12160 default:
12161 panic("unknown field " + strconv.Quote(field.Name))
12162 }
12163 }
12164 out.Dispatch()
12165 if invalids > 0 {
12166 return graphql.Null
12167 }
12168 return out
12169}
12170
12171var labelChangeResultImplementors = []string{"LabelChangeResult"}
12172
12173func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
12174 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
12175
12176 out := graphql.NewFieldSet(fields)
12177 var invalids uint32
12178 for i, field := range fields {
12179 switch field.Name {
12180 case "__typename":
12181 out.Values[i] = graphql.MarshalString("LabelChangeResult")
12182 case "label":
12183 out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
12184 if out.Values[i] == graphql.Null {
12185 atomic.AddUint32(&invalids, 1)
12186 }
12187 case "status":
12188 field := field
12189 out.Concurrently(i, func() (res graphql.Marshaler) {
12190 defer func() {
12191 if r := recover(); r != nil {
12192 ec.Error(ctx, ec.Recover(ctx, r))
12193 }
12194 }()
12195 res = ec._LabelChangeResult_status(ctx, field, obj)
12196 if res == graphql.Null {
12197 atomic.AddUint32(&invalids, 1)
12198 }
12199 return res
12200 })
12201 default:
12202 panic("unknown field " + strconv.Quote(field.Name))
12203 }
12204 }
12205 out.Dispatch()
12206 if invalids > 0 {
12207 return graphql.Null
12208 }
12209 return out
12210}
12211
12212var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
12213
12214func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
12215 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
12216
12217 out := graphql.NewFieldSet(fields)
12218 var invalids uint32
12219 for i, field := range fields {
12220 switch field.Name {
12221 case "__typename":
12222 out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
12223 case "id":
12224 field := field
12225 out.Concurrently(i, func() (res graphql.Marshaler) {
12226 defer func() {
12227 if r := recover(); r != nil {
12228 ec.Error(ctx, ec.Recover(ctx, r))
12229 }
12230 }()
12231 res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
12232 if res == graphql.Null {
12233 atomic.AddUint32(&invalids, 1)
12234 }
12235 return res
12236 })
12237 case "author":
12238 field := field
12239 out.Concurrently(i, func() (res graphql.Marshaler) {
12240 defer func() {
12241 if r := recover(); r != nil {
12242 ec.Error(ctx, ec.Recover(ctx, r))
12243 }
12244 }()
12245 res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
12246 if res == graphql.Null {
12247 atomic.AddUint32(&invalids, 1)
12248 }
12249 return res
12250 })
12251 case "date":
12252 field := field
12253 out.Concurrently(i, func() (res graphql.Marshaler) {
12254 defer func() {
12255 if r := recover(); r != nil {
12256 ec.Error(ctx, ec.Recover(ctx, r))
12257 }
12258 }()
12259 res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
12260 if res == graphql.Null {
12261 atomic.AddUint32(&invalids, 1)
12262 }
12263 return res
12264 })
12265 case "added":
12266 out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
12267 if out.Values[i] == graphql.Null {
12268 atomic.AddUint32(&invalids, 1)
12269 }
12270 case "removed":
12271 out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
12272 if out.Values[i] == graphql.Null {
12273 atomic.AddUint32(&invalids, 1)
12274 }
12275 default:
12276 panic("unknown field " + strconv.Quote(field.Name))
12277 }
12278 }
12279 out.Dispatch()
12280 if invalids > 0 {
12281 return graphql.Null
12282 }
12283 return out
12284}
12285
12286var labelConnectionImplementors = []string{"LabelConnection"}
12287
12288func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
12289 fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
12290
12291 out := graphql.NewFieldSet(fields)
12292 var invalids uint32
12293 for i, field := range fields {
12294 switch field.Name {
12295 case "__typename":
12296 out.Values[i] = graphql.MarshalString("LabelConnection")
12297 case "edges":
12298 out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
12299 if out.Values[i] == graphql.Null {
12300 invalids++
12301 }
12302 case "nodes":
12303 out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
12304 if out.Values[i] == graphql.Null {
12305 invalids++
12306 }
12307 case "pageInfo":
12308 out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
12309 if out.Values[i] == graphql.Null {
12310 invalids++
12311 }
12312 case "totalCount":
12313 out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
12314 if out.Values[i] == graphql.Null {
12315 invalids++
12316 }
12317 default:
12318 panic("unknown field " + strconv.Quote(field.Name))
12319 }
12320 }
12321 out.Dispatch()
12322 if invalids > 0 {
12323 return graphql.Null
12324 }
12325 return out
12326}
12327
12328var labelEdgeImplementors = []string{"LabelEdge"}
12329
12330func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
12331 fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
12332
12333 out := graphql.NewFieldSet(fields)
12334 var invalids uint32
12335 for i, field := range fields {
12336 switch field.Name {
12337 case "__typename":
12338 out.Values[i] = graphql.MarshalString("LabelEdge")
12339 case "cursor":
12340 out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
12341 if out.Values[i] == graphql.Null {
12342 invalids++
12343 }
12344 case "node":
12345 out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
12346 if out.Values[i] == graphql.Null {
12347 invalids++
12348 }
12349 default:
12350 panic("unknown field " + strconv.Quote(field.Name))
12351 }
12352 }
12353 out.Dispatch()
12354 if invalids > 0 {
12355 return graphql.Null
12356 }
12357 return out
12358}
12359
12360var mutationImplementors = []string{"Mutation"}
12361
12362func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12363 fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
12364
12365 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12366 Object: "Mutation",
12367 })
12368
12369 out := graphql.NewFieldSet(fields)
12370 var invalids uint32
12371 for i, field := range fields {
12372 switch field.Name {
12373 case "__typename":
12374 out.Values[i] = graphql.MarshalString("Mutation")
12375 case "newBug":
12376 out.Values[i] = ec._Mutation_newBug(ctx, field)
12377 if out.Values[i] == graphql.Null {
12378 invalids++
12379 }
12380 case "addComment":
12381 out.Values[i] = ec._Mutation_addComment(ctx, field)
12382 if out.Values[i] == graphql.Null {
12383 invalids++
12384 }
12385 case "addCommentAndClose":
12386 out.Values[i] = ec._Mutation_addCommentAndClose(ctx, field)
12387 if out.Values[i] == graphql.Null {
12388 invalids++
12389 }
12390 case "editComment":
12391 out.Values[i] = ec._Mutation_editComment(ctx, field)
12392 if out.Values[i] == graphql.Null {
12393 invalids++
12394 }
12395 case "changeLabels":
12396 out.Values[i] = ec._Mutation_changeLabels(ctx, field)
12397 if out.Values[i] == graphql.Null {
12398 invalids++
12399 }
12400 case "openBug":
12401 out.Values[i] = ec._Mutation_openBug(ctx, field)
12402 if out.Values[i] == graphql.Null {
12403 invalids++
12404 }
12405 case "closeBug":
12406 out.Values[i] = ec._Mutation_closeBug(ctx, field)
12407 if out.Values[i] == graphql.Null {
12408 invalids++
12409 }
12410 case "setTitle":
12411 out.Values[i] = ec._Mutation_setTitle(ctx, field)
12412 if out.Values[i] == graphql.Null {
12413 invalids++
12414 }
12415 default:
12416 panic("unknown field " + strconv.Quote(field.Name))
12417 }
12418 }
12419 out.Dispatch()
12420 if invalids > 0 {
12421 return graphql.Null
12422 }
12423 return out
12424}
12425
12426var newBugPayloadImplementors = []string{"NewBugPayload"}
12427
12428func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
12429 fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
12430
12431 out := graphql.NewFieldSet(fields)
12432 var invalids uint32
12433 for i, field := range fields {
12434 switch field.Name {
12435 case "__typename":
12436 out.Values[i] = graphql.MarshalString("NewBugPayload")
12437 case "clientMutationId":
12438 out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
12439 case "bug":
12440 out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
12441 if out.Values[i] == graphql.Null {
12442 invalids++
12443 }
12444 case "operation":
12445 out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
12446 if out.Values[i] == graphql.Null {
12447 invalids++
12448 }
12449 default:
12450 panic("unknown field " + strconv.Quote(field.Name))
12451 }
12452 }
12453 out.Dispatch()
12454 if invalids > 0 {
12455 return graphql.Null
12456 }
12457 return out
12458}
12459
12460var openBugPayloadImplementors = []string{"OpenBugPayload"}
12461
12462func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
12463 fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
12464
12465 out := graphql.NewFieldSet(fields)
12466 var invalids uint32
12467 for i, field := range fields {
12468 switch field.Name {
12469 case "__typename":
12470 out.Values[i] = graphql.MarshalString("OpenBugPayload")
12471 case "clientMutationId":
12472 out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
12473 case "bug":
12474 out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
12475 if out.Values[i] == graphql.Null {
12476 invalids++
12477 }
12478 case "operation":
12479 out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
12480 if out.Values[i] == graphql.Null {
12481 invalids++
12482 }
12483 default:
12484 panic("unknown field " + strconv.Quote(field.Name))
12485 }
12486 }
12487 out.Dispatch()
12488 if invalids > 0 {
12489 return graphql.Null
12490 }
12491 return out
12492}
12493
12494var operationConnectionImplementors = []string{"OperationConnection"}
12495
12496func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
12497 fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
12498
12499 out := graphql.NewFieldSet(fields)
12500 var invalids uint32
12501 for i, field := range fields {
12502 switch field.Name {
12503 case "__typename":
12504 out.Values[i] = graphql.MarshalString("OperationConnection")
12505 case "edges":
12506 out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
12507 if out.Values[i] == graphql.Null {
12508 invalids++
12509 }
12510 case "nodes":
12511 out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
12512 if out.Values[i] == graphql.Null {
12513 invalids++
12514 }
12515 case "pageInfo":
12516 out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
12517 if out.Values[i] == graphql.Null {
12518 invalids++
12519 }
12520 case "totalCount":
12521 out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
12522 if out.Values[i] == graphql.Null {
12523 invalids++
12524 }
12525 default:
12526 panic("unknown field " + strconv.Quote(field.Name))
12527 }
12528 }
12529 out.Dispatch()
12530 if invalids > 0 {
12531 return graphql.Null
12532 }
12533 return out
12534}
12535
12536var operationEdgeImplementors = []string{"OperationEdge"}
12537
12538func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
12539 fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
12540
12541 out := graphql.NewFieldSet(fields)
12542 var invalids uint32
12543 for i, field := range fields {
12544 switch field.Name {
12545 case "__typename":
12546 out.Values[i] = graphql.MarshalString("OperationEdge")
12547 case "cursor":
12548 out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
12549 if out.Values[i] == graphql.Null {
12550 invalids++
12551 }
12552 case "node":
12553 out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
12554 if out.Values[i] == graphql.Null {
12555 invalids++
12556 }
12557 default:
12558 panic("unknown field " + strconv.Quote(field.Name))
12559 }
12560 }
12561 out.Dispatch()
12562 if invalids > 0 {
12563 return graphql.Null
12564 }
12565 return out
12566}
12567
12568var pageInfoImplementors = []string{"PageInfo"}
12569
12570func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
12571 fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
12572
12573 out := graphql.NewFieldSet(fields)
12574 var invalids uint32
12575 for i, field := range fields {
12576 switch field.Name {
12577 case "__typename":
12578 out.Values[i] = graphql.MarshalString("PageInfo")
12579 case "hasNextPage":
12580 out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
12581 if out.Values[i] == graphql.Null {
12582 invalids++
12583 }
12584 case "hasPreviousPage":
12585 out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
12586 if out.Values[i] == graphql.Null {
12587 invalids++
12588 }
12589 case "startCursor":
12590 out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
12591 if out.Values[i] == graphql.Null {
12592 invalids++
12593 }
12594 case "endCursor":
12595 out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
12596 if out.Values[i] == graphql.Null {
12597 invalids++
12598 }
12599 default:
12600 panic("unknown field " + strconv.Quote(field.Name))
12601 }
12602 }
12603 out.Dispatch()
12604 if invalids > 0 {
12605 return graphql.Null
12606 }
12607 return out
12608}
12609
12610var queryImplementors = []string{"Query"}
12611
12612func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12613 fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
12614
12615 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12616 Object: "Query",
12617 })
12618
12619 out := graphql.NewFieldSet(fields)
12620 var invalids uint32
12621 for i, field := range fields {
12622 switch field.Name {
12623 case "__typename":
12624 out.Values[i] = graphql.MarshalString("Query")
12625 case "repository":
12626 field := field
12627 out.Concurrently(i, func() (res graphql.Marshaler) {
12628 defer func() {
12629 if r := recover(); r != nil {
12630 ec.Error(ctx, ec.Recover(ctx, r))
12631 }
12632 }()
12633 res = ec._Query_repository(ctx, field)
12634 return res
12635 })
12636 case "__type":
12637 out.Values[i] = ec._Query___type(ctx, field)
12638 case "__schema":
12639 out.Values[i] = ec._Query___schema(ctx, field)
12640 default:
12641 panic("unknown field " + strconv.Quote(field.Name))
12642 }
12643 }
12644 out.Dispatch()
12645 if invalids > 0 {
12646 return graphql.Null
12647 }
12648 return out
12649}
12650
12651var repositoryImplementors = []string{"Repository"}
12652
12653func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
12654 fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
12655
12656 out := graphql.NewFieldSet(fields)
12657 var invalids uint32
12658 for i, field := range fields {
12659 switch field.Name {
12660 case "__typename":
12661 out.Values[i] = graphql.MarshalString("Repository")
12662 case "name":
12663 field := field
12664 out.Concurrently(i, func() (res graphql.Marshaler) {
12665 defer func() {
12666 if r := recover(); r != nil {
12667 ec.Error(ctx, ec.Recover(ctx, r))
12668 }
12669 }()
12670 res = ec._Repository_name(ctx, field, obj)
12671 return res
12672 })
12673 case "allBugs":
12674 field := field
12675 out.Concurrently(i, func() (res graphql.Marshaler) {
12676 defer func() {
12677 if r := recover(); r != nil {
12678 ec.Error(ctx, ec.Recover(ctx, r))
12679 }
12680 }()
12681 res = ec._Repository_allBugs(ctx, field, obj)
12682 if res == graphql.Null {
12683 atomic.AddUint32(&invalids, 1)
12684 }
12685 return res
12686 })
12687 case "bug":
12688 field := field
12689 out.Concurrently(i, func() (res graphql.Marshaler) {
12690 defer func() {
12691 if r := recover(); r != nil {
12692 ec.Error(ctx, ec.Recover(ctx, r))
12693 }
12694 }()
12695 res = ec._Repository_bug(ctx, field, obj)
12696 return res
12697 })
12698 case "allIdentities":
12699 field := field
12700 out.Concurrently(i, func() (res graphql.Marshaler) {
12701 defer func() {
12702 if r := recover(); r != nil {
12703 ec.Error(ctx, ec.Recover(ctx, r))
12704 }
12705 }()
12706 res = ec._Repository_allIdentities(ctx, field, obj)
12707 if res == graphql.Null {
12708 atomic.AddUint32(&invalids, 1)
12709 }
12710 return res
12711 })
12712 case "identity":
12713 field := field
12714 out.Concurrently(i, func() (res graphql.Marshaler) {
12715 defer func() {
12716 if r := recover(); r != nil {
12717 ec.Error(ctx, ec.Recover(ctx, r))
12718 }
12719 }()
12720 res = ec._Repository_identity(ctx, field, obj)
12721 return res
12722 })
12723 case "userIdentity":
12724 field := field
12725 out.Concurrently(i, func() (res graphql.Marshaler) {
12726 defer func() {
12727 if r := recover(); r != nil {
12728 ec.Error(ctx, ec.Recover(ctx, r))
12729 }
12730 }()
12731 res = ec._Repository_userIdentity(ctx, field, obj)
12732 return res
12733 })
12734 case "validLabels":
12735 field := field
12736 out.Concurrently(i, func() (res graphql.Marshaler) {
12737 defer func() {
12738 if r := recover(); r != nil {
12739 ec.Error(ctx, ec.Recover(ctx, r))
12740 }
12741 }()
12742 res = ec._Repository_validLabels(ctx, field, obj)
12743 if res == graphql.Null {
12744 atomic.AddUint32(&invalids, 1)
12745 }
12746 return res
12747 })
12748 default:
12749 panic("unknown field " + strconv.Quote(field.Name))
12750 }
12751 }
12752 out.Dispatch()
12753 if invalids > 0 {
12754 return graphql.Null
12755 }
12756 return out
12757}
12758
12759var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
12760
12761func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
12762 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
12763
12764 out := graphql.NewFieldSet(fields)
12765 var invalids uint32
12766 for i, field := range fields {
12767 switch field.Name {
12768 case "__typename":
12769 out.Values[i] = graphql.MarshalString("SetStatusOperation")
12770 case "id":
12771 field := field
12772 out.Concurrently(i, func() (res graphql.Marshaler) {
12773 defer func() {
12774 if r := recover(); r != nil {
12775 ec.Error(ctx, ec.Recover(ctx, r))
12776 }
12777 }()
12778 res = ec._SetStatusOperation_id(ctx, field, obj)
12779 if res == graphql.Null {
12780 atomic.AddUint32(&invalids, 1)
12781 }
12782 return res
12783 })
12784 case "author":
12785 field := field
12786 out.Concurrently(i, func() (res graphql.Marshaler) {
12787 defer func() {
12788 if r := recover(); r != nil {
12789 ec.Error(ctx, ec.Recover(ctx, r))
12790 }
12791 }()
12792 res = ec._SetStatusOperation_author(ctx, field, obj)
12793 if res == graphql.Null {
12794 atomic.AddUint32(&invalids, 1)
12795 }
12796 return res
12797 })
12798 case "date":
12799 field := field
12800 out.Concurrently(i, func() (res graphql.Marshaler) {
12801 defer func() {
12802 if r := recover(); r != nil {
12803 ec.Error(ctx, ec.Recover(ctx, r))
12804 }
12805 }()
12806 res = ec._SetStatusOperation_date(ctx, field, obj)
12807 if res == graphql.Null {
12808 atomic.AddUint32(&invalids, 1)
12809 }
12810 return res
12811 })
12812 case "status":
12813 field := field
12814 out.Concurrently(i, func() (res graphql.Marshaler) {
12815 defer func() {
12816 if r := recover(); r != nil {
12817 ec.Error(ctx, ec.Recover(ctx, r))
12818 }
12819 }()
12820 res = ec._SetStatusOperation_status(ctx, field, obj)
12821 if res == graphql.Null {
12822 atomic.AddUint32(&invalids, 1)
12823 }
12824 return res
12825 })
12826 default:
12827 panic("unknown field " + strconv.Quote(field.Name))
12828 }
12829 }
12830 out.Dispatch()
12831 if invalids > 0 {
12832 return graphql.Null
12833 }
12834 return out
12835}
12836
12837var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
12838
12839func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
12840 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
12841
12842 out := graphql.NewFieldSet(fields)
12843 var invalids uint32
12844 for i, field := range fields {
12845 switch field.Name {
12846 case "__typename":
12847 out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
12848 case "id":
12849 field := field
12850 out.Concurrently(i, func() (res graphql.Marshaler) {
12851 defer func() {
12852 if r := recover(); r != nil {
12853 ec.Error(ctx, ec.Recover(ctx, r))
12854 }
12855 }()
12856 res = ec._SetStatusTimelineItem_id(ctx, field, obj)
12857 if res == graphql.Null {
12858 atomic.AddUint32(&invalids, 1)
12859 }
12860 return res
12861 })
12862 case "author":
12863 field := field
12864 out.Concurrently(i, func() (res graphql.Marshaler) {
12865 defer func() {
12866 if r := recover(); r != nil {
12867 ec.Error(ctx, ec.Recover(ctx, r))
12868 }
12869 }()
12870 res = ec._SetStatusTimelineItem_author(ctx, field, obj)
12871 if res == graphql.Null {
12872 atomic.AddUint32(&invalids, 1)
12873 }
12874 return res
12875 })
12876 case "date":
12877 field := field
12878 out.Concurrently(i, func() (res graphql.Marshaler) {
12879 defer func() {
12880 if r := recover(); r != nil {
12881 ec.Error(ctx, ec.Recover(ctx, r))
12882 }
12883 }()
12884 res = ec._SetStatusTimelineItem_date(ctx, field, obj)
12885 if res == graphql.Null {
12886 atomic.AddUint32(&invalids, 1)
12887 }
12888 return res
12889 })
12890 case "status":
12891 field := field
12892 out.Concurrently(i, func() (res graphql.Marshaler) {
12893 defer func() {
12894 if r := recover(); r != nil {
12895 ec.Error(ctx, ec.Recover(ctx, r))
12896 }
12897 }()
12898 res = ec._SetStatusTimelineItem_status(ctx, field, obj)
12899 if res == graphql.Null {
12900 atomic.AddUint32(&invalids, 1)
12901 }
12902 return res
12903 })
12904 default:
12905 panic("unknown field " + strconv.Quote(field.Name))
12906 }
12907 }
12908 out.Dispatch()
12909 if invalids > 0 {
12910 return graphql.Null
12911 }
12912 return out
12913}
12914
12915var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
12916
12917func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
12918 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
12919
12920 out := graphql.NewFieldSet(fields)
12921 var invalids uint32
12922 for i, field := range fields {
12923 switch field.Name {
12924 case "__typename":
12925 out.Values[i] = graphql.MarshalString("SetTitleOperation")
12926 case "id":
12927 field := field
12928 out.Concurrently(i, func() (res graphql.Marshaler) {
12929 defer func() {
12930 if r := recover(); r != nil {
12931 ec.Error(ctx, ec.Recover(ctx, r))
12932 }
12933 }()
12934 res = ec._SetTitleOperation_id(ctx, field, obj)
12935 if res == graphql.Null {
12936 atomic.AddUint32(&invalids, 1)
12937 }
12938 return res
12939 })
12940 case "author":
12941 field := field
12942 out.Concurrently(i, func() (res graphql.Marshaler) {
12943 defer func() {
12944 if r := recover(); r != nil {
12945 ec.Error(ctx, ec.Recover(ctx, r))
12946 }
12947 }()
12948 res = ec._SetTitleOperation_author(ctx, field, obj)
12949 if res == graphql.Null {
12950 atomic.AddUint32(&invalids, 1)
12951 }
12952 return res
12953 })
12954 case "date":
12955 field := field
12956 out.Concurrently(i, func() (res graphql.Marshaler) {
12957 defer func() {
12958 if r := recover(); r != nil {
12959 ec.Error(ctx, ec.Recover(ctx, r))
12960 }
12961 }()
12962 res = ec._SetTitleOperation_date(ctx, field, obj)
12963 if res == graphql.Null {
12964 atomic.AddUint32(&invalids, 1)
12965 }
12966 return res
12967 })
12968 case "title":
12969 out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
12970 if out.Values[i] == graphql.Null {
12971 atomic.AddUint32(&invalids, 1)
12972 }
12973 case "was":
12974 out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
12975 if out.Values[i] == graphql.Null {
12976 atomic.AddUint32(&invalids, 1)
12977 }
12978 default:
12979 panic("unknown field " + strconv.Quote(field.Name))
12980 }
12981 }
12982 out.Dispatch()
12983 if invalids > 0 {
12984 return graphql.Null
12985 }
12986 return out
12987}
12988
12989var setTitlePayloadImplementors = []string{"SetTitlePayload"}
12990
12991func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
12992 fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
12993
12994 out := graphql.NewFieldSet(fields)
12995 var invalids uint32
12996 for i, field := range fields {
12997 switch field.Name {
12998 case "__typename":
12999 out.Values[i] = graphql.MarshalString("SetTitlePayload")
13000 case "clientMutationId":
13001 out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
13002 case "bug":
13003 out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
13004 if out.Values[i] == graphql.Null {
13005 invalids++
13006 }
13007 case "operation":
13008 out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
13009 if out.Values[i] == graphql.Null {
13010 invalids++
13011 }
13012 default:
13013 panic("unknown field " + strconv.Quote(field.Name))
13014 }
13015 }
13016 out.Dispatch()
13017 if invalids > 0 {
13018 return graphql.Null
13019 }
13020 return out
13021}
13022
13023var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
13024
13025func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
13026 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
13027
13028 out := graphql.NewFieldSet(fields)
13029 var invalids uint32
13030 for i, field := range fields {
13031 switch field.Name {
13032 case "__typename":
13033 out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
13034 case "id":
13035 field := field
13036 out.Concurrently(i, func() (res graphql.Marshaler) {
13037 defer func() {
13038 if r := recover(); r != nil {
13039 ec.Error(ctx, ec.Recover(ctx, r))
13040 }
13041 }()
13042 res = ec._SetTitleTimelineItem_id(ctx, field, obj)
13043 if res == graphql.Null {
13044 atomic.AddUint32(&invalids, 1)
13045 }
13046 return res
13047 })
13048 case "author":
13049 field := field
13050 out.Concurrently(i, func() (res graphql.Marshaler) {
13051 defer func() {
13052 if r := recover(); r != nil {
13053 ec.Error(ctx, ec.Recover(ctx, r))
13054 }
13055 }()
13056 res = ec._SetTitleTimelineItem_author(ctx, field, obj)
13057 if res == graphql.Null {
13058 atomic.AddUint32(&invalids, 1)
13059 }
13060 return res
13061 })
13062 case "date":
13063 field := field
13064 out.Concurrently(i, func() (res graphql.Marshaler) {
13065 defer func() {
13066 if r := recover(); r != nil {
13067 ec.Error(ctx, ec.Recover(ctx, r))
13068 }
13069 }()
13070 res = ec._SetTitleTimelineItem_date(ctx, field, obj)
13071 if res == graphql.Null {
13072 atomic.AddUint32(&invalids, 1)
13073 }
13074 return res
13075 })
13076 case "title":
13077 out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
13078 if out.Values[i] == graphql.Null {
13079 atomic.AddUint32(&invalids, 1)
13080 }
13081 case "was":
13082 out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
13083 if out.Values[i] == graphql.Null {
13084 atomic.AddUint32(&invalids, 1)
13085 }
13086 default:
13087 panic("unknown field " + strconv.Quote(field.Name))
13088 }
13089 }
13090 out.Dispatch()
13091 if invalids > 0 {
13092 return graphql.Null
13093 }
13094 return out
13095}
13096
13097var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
13098
13099func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
13100 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
13101
13102 out := graphql.NewFieldSet(fields)
13103 var invalids uint32
13104 for i, field := range fields {
13105 switch field.Name {
13106 case "__typename":
13107 out.Values[i] = graphql.MarshalString("TimelineItemConnection")
13108 case "edges":
13109 out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
13110 if out.Values[i] == graphql.Null {
13111 invalids++
13112 }
13113 case "nodes":
13114 out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
13115 if out.Values[i] == graphql.Null {
13116 invalids++
13117 }
13118 case "pageInfo":
13119 out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
13120 if out.Values[i] == graphql.Null {
13121 invalids++
13122 }
13123 case "totalCount":
13124 out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
13125 if out.Values[i] == graphql.Null {
13126 invalids++
13127 }
13128 default:
13129 panic("unknown field " + strconv.Quote(field.Name))
13130 }
13131 }
13132 out.Dispatch()
13133 if invalids > 0 {
13134 return graphql.Null
13135 }
13136 return out
13137}
13138
13139var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
13140
13141func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
13142 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
13143
13144 out := graphql.NewFieldSet(fields)
13145 var invalids uint32
13146 for i, field := range fields {
13147 switch field.Name {
13148 case "__typename":
13149 out.Values[i] = graphql.MarshalString("TimelineItemEdge")
13150 case "cursor":
13151 out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
13152 if out.Values[i] == graphql.Null {
13153 invalids++
13154 }
13155 case "node":
13156 out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
13157 if out.Values[i] == graphql.Null {
13158 invalids++
13159 }
13160 default:
13161 panic("unknown field " + strconv.Quote(field.Name))
13162 }
13163 }
13164 out.Dispatch()
13165 if invalids > 0 {
13166 return graphql.Null
13167 }
13168 return out
13169}
13170
13171var __DirectiveImplementors = []string{"__Directive"}
13172
13173func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
13174 fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
13175
13176 out := graphql.NewFieldSet(fields)
13177 var invalids uint32
13178 for i, field := range fields {
13179 switch field.Name {
13180 case "__typename":
13181 out.Values[i] = graphql.MarshalString("__Directive")
13182 case "name":
13183 out.Values[i] = ec.___Directive_name(ctx, field, obj)
13184 if out.Values[i] == graphql.Null {
13185 invalids++
13186 }
13187 case "description":
13188 out.Values[i] = ec.___Directive_description(ctx, field, obj)
13189 case "locations":
13190 out.Values[i] = ec.___Directive_locations(ctx, field, obj)
13191 if out.Values[i] == graphql.Null {
13192 invalids++
13193 }
13194 case "args":
13195 out.Values[i] = ec.___Directive_args(ctx, field, obj)
13196 if out.Values[i] == graphql.Null {
13197 invalids++
13198 }
13199 default:
13200 panic("unknown field " + strconv.Quote(field.Name))
13201 }
13202 }
13203 out.Dispatch()
13204 if invalids > 0 {
13205 return graphql.Null
13206 }
13207 return out
13208}
13209
13210var __EnumValueImplementors = []string{"__EnumValue"}
13211
13212func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
13213 fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
13214
13215 out := graphql.NewFieldSet(fields)
13216 var invalids uint32
13217 for i, field := range fields {
13218 switch field.Name {
13219 case "__typename":
13220 out.Values[i] = graphql.MarshalString("__EnumValue")
13221 case "name":
13222 out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
13223 if out.Values[i] == graphql.Null {
13224 invalids++
13225 }
13226 case "description":
13227 out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
13228 case "isDeprecated":
13229 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
13230 if out.Values[i] == graphql.Null {
13231 invalids++
13232 }
13233 case "deprecationReason":
13234 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
13235 default:
13236 panic("unknown field " + strconv.Quote(field.Name))
13237 }
13238 }
13239 out.Dispatch()
13240 if invalids > 0 {
13241 return graphql.Null
13242 }
13243 return out
13244}
13245
13246var __FieldImplementors = []string{"__Field"}
13247
13248func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
13249 fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
13250
13251 out := graphql.NewFieldSet(fields)
13252 var invalids uint32
13253 for i, field := range fields {
13254 switch field.Name {
13255 case "__typename":
13256 out.Values[i] = graphql.MarshalString("__Field")
13257 case "name":
13258 out.Values[i] = ec.___Field_name(ctx, field, obj)
13259 if out.Values[i] == graphql.Null {
13260 invalids++
13261 }
13262 case "description":
13263 out.Values[i] = ec.___Field_description(ctx, field, obj)
13264 case "args":
13265 out.Values[i] = ec.___Field_args(ctx, field, obj)
13266 if out.Values[i] == graphql.Null {
13267 invalids++
13268 }
13269 case "type":
13270 out.Values[i] = ec.___Field_type(ctx, field, obj)
13271 if out.Values[i] == graphql.Null {
13272 invalids++
13273 }
13274 case "isDeprecated":
13275 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
13276 if out.Values[i] == graphql.Null {
13277 invalids++
13278 }
13279 case "deprecationReason":
13280 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
13281 default:
13282 panic("unknown field " + strconv.Quote(field.Name))
13283 }
13284 }
13285 out.Dispatch()
13286 if invalids > 0 {
13287 return graphql.Null
13288 }
13289 return out
13290}
13291
13292var __InputValueImplementors = []string{"__InputValue"}
13293
13294func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
13295 fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
13296
13297 out := graphql.NewFieldSet(fields)
13298 var invalids uint32
13299 for i, field := range fields {
13300 switch field.Name {
13301 case "__typename":
13302 out.Values[i] = graphql.MarshalString("__InputValue")
13303 case "name":
13304 out.Values[i] = ec.___InputValue_name(ctx, field, obj)
13305 if out.Values[i] == graphql.Null {
13306 invalids++
13307 }
13308 case "description":
13309 out.Values[i] = ec.___InputValue_description(ctx, field, obj)
13310 case "type":
13311 out.Values[i] = ec.___InputValue_type(ctx, field, obj)
13312 if out.Values[i] == graphql.Null {
13313 invalids++
13314 }
13315 case "defaultValue":
13316 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
13317 default:
13318 panic("unknown field " + strconv.Quote(field.Name))
13319 }
13320 }
13321 out.Dispatch()
13322 if invalids > 0 {
13323 return graphql.Null
13324 }
13325 return out
13326}
13327
13328var __SchemaImplementors = []string{"__Schema"}
13329
13330func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
13331 fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
13332
13333 out := graphql.NewFieldSet(fields)
13334 var invalids uint32
13335 for i, field := range fields {
13336 switch field.Name {
13337 case "__typename":
13338 out.Values[i] = graphql.MarshalString("__Schema")
13339 case "types":
13340 out.Values[i] = ec.___Schema_types(ctx, field, obj)
13341 if out.Values[i] == graphql.Null {
13342 invalids++
13343 }
13344 case "queryType":
13345 out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
13346 if out.Values[i] == graphql.Null {
13347 invalids++
13348 }
13349 case "mutationType":
13350 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
13351 case "subscriptionType":
13352 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
13353 case "directives":
13354 out.Values[i] = ec.___Schema_directives(ctx, field, obj)
13355 if out.Values[i] == graphql.Null {
13356 invalids++
13357 }
13358 default:
13359 panic("unknown field " + strconv.Quote(field.Name))
13360 }
13361 }
13362 out.Dispatch()
13363 if invalids > 0 {
13364 return graphql.Null
13365 }
13366 return out
13367}
13368
13369var __TypeImplementors = []string{"__Type"}
13370
13371func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
13372 fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
13373
13374 out := graphql.NewFieldSet(fields)
13375 var invalids uint32
13376 for i, field := range fields {
13377 switch field.Name {
13378 case "__typename":
13379 out.Values[i] = graphql.MarshalString("__Type")
13380 case "kind":
13381 out.Values[i] = ec.___Type_kind(ctx, field, obj)
13382 if out.Values[i] == graphql.Null {
13383 invalids++
13384 }
13385 case "name":
13386 out.Values[i] = ec.___Type_name(ctx, field, obj)
13387 case "description":
13388 out.Values[i] = ec.___Type_description(ctx, field, obj)
13389 case "fields":
13390 out.Values[i] = ec.___Type_fields(ctx, field, obj)
13391 case "interfaces":
13392 out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
13393 case "possibleTypes":
13394 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
13395 case "enumValues":
13396 out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
13397 case "inputFields":
13398 out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
13399 case "ofType":
13400 out.Values[i] = ec.___Type_ofType(ctx, field, obj)
13401 default:
13402 panic("unknown field " + strconv.Quote(field.Name))
13403 }
13404 }
13405 out.Dispatch()
13406 if invalids > 0 {
13407 return graphql.Null
13408 }
13409 return out
13410}
13411
13412// endregion **************************** object.gotpl ****************************
13413
13414// region ***************************** type.gotpl *****************************
13415
13416func (ec *executionContext) unmarshalNAddCommentAndCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugInput(ctx context.Context, v interface{}) (models.AddCommentAndCloseBugInput, error) {
13417 return ec.unmarshalInputAddCommentAndCloseBugInput(ctx, v)
13418}
13419
13420func (ec *executionContext) marshalNAddCommentAndCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentAndCloseBugPayload) graphql.Marshaler {
13421 return ec._AddCommentAndCloseBugPayload(ctx, sel, &v)
13422}
13423
13424func (ec *executionContext) marshalNAddCommentAndCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentAndCloseBugPayload) graphql.Marshaler {
13425 if v == nil {
13426 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13427 ec.Errorf(ctx, "must not be null")
13428 }
13429 return graphql.Null
13430 }
13431 return ec._AddCommentAndCloseBugPayload(ctx, sel, v)
13432}
13433
13434func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
13435 return ec.unmarshalInputAddCommentInput(ctx, v)
13436}
13437
13438func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
13439 return ec._AddCommentOperation(ctx, sel, &v)
13440}
13441
13442func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) 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._AddCommentOperation(ctx, sel, v)
13450}
13451
13452func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
13453 return ec._AddCommentPayload(ctx, sel, &v)
13454}
13455
13456func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
13457 if v == nil {
13458 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13459 ec.Errorf(ctx, "must not be null")
13460 }
13461 return graphql.Null
13462 }
13463 return ec._AddCommentPayload(ctx, sel, v)
13464}
13465
13466func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
13467 return graphql.UnmarshalBoolean(v)
13468}
13469
13470func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
13471 res := graphql.MarshalBoolean(v)
13472 if res == graphql.Null {
13473 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13474 ec.Errorf(ctx, "must not be null")
13475 }
13476 }
13477 return res
13478}
13479
13480func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
13481 if v == nil {
13482 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13483 ec.Errorf(ctx, "must not be null")
13484 }
13485 return graphql.Null
13486 }
13487 return ec._Bug(ctx, sel, v)
13488}
13489
13490func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
13491 ret := make(graphql.Array, len(v))
13492 var wg sync.WaitGroup
13493 isLen1 := len(v) == 1
13494 if !isLen1 {
13495 wg.Add(len(v))
13496 }
13497 for i := range v {
13498 i := i
13499 fc := &graphql.FieldContext{
13500 Index: &i,
13501 Result: &v[i],
13502 }
13503 ctx := graphql.WithFieldContext(ctx, fc)
13504 f := func(i int) {
13505 defer func() {
13506 if r := recover(); r != nil {
13507 ec.Error(ctx, ec.Recover(ctx, r))
13508 ret = nil
13509 }
13510 }()
13511 if !isLen1 {
13512 defer wg.Done()
13513 }
13514 ret[i] = ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
13515 }
13516 if isLen1 {
13517 f(i)
13518 } else {
13519 go f(i)
13520 }
13521
13522 }
13523 wg.Wait()
13524 return ret
13525}
13526
13527func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
13528 return ec._BugConnection(ctx, sel, &v)
13529}
13530
13531func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
13532 if v == nil {
13533 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13534 ec.Errorf(ctx, "must not be null")
13535 }
13536 return graphql.Null
13537 }
13538 return ec._BugConnection(ctx, sel, v)
13539}
13540
13541func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
13542 return ec._BugEdge(ctx, sel, &v)
13543}
13544
13545func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
13546 ret := make(graphql.Array, len(v))
13547 var wg sync.WaitGroup
13548 isLen1 := len(v) == 1
13549 if !isLen1 {
13550 wg.Add(len(v))
13551 }
13552 for i := range v {
13553 i := i
13554 fc := &graphql.FieldContext{
13555 Index: &i,
13556 Result: &v[i],
13557 }
13558 ctx := graphql.WithFieldContext(ctx, fc)
13559 f := func(i int) {
13560 defer func() {
13561 if r := recover(); r != nil {
13562 ec.Error(ctx, ec.Recover(ctx, r))
13563 ret = nil
13564 }
13565 }()
13566 if !isLen1 {
13567 defer wg.Done()
13568 }
13569 ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
13570 }
13571 if isLen1 {
13572 f(i)
13573 } else {
13574 go f(i)
13575 }
13576
13577 }
13578 wg.Wait()
13579 return ret
13580}
13581
13582func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
13583 if v == nil {
13584 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13585 ec.Errorf(ctx, "must not be null")
13586 }
13587 return graphql.Null
13588 }
13589 return ec._BugEdge(ctx, sel, v)
13590}
13591
13592func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
13593 return ec._ChangeLabelPayload(ctx, sel, &v)
13594}
13595
13596func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
13597 if v == nil {
13598 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13599 ec.Errorf(ctx, "must not be null")
13600 }
13601 return graphql.Null
13602 }
13603 return ec._ChangeLabelPayload(ctx, sel, v)
13604}
13605
13606func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
13607 return ec.unmarshalInputCloseBugInput(ctx, v)
13608}
13609
13610func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
13611 return ec._CloseBugPayload(ctx, sel, &v)
13612}
13613
13614func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
13615 if v == nil {
13616 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13617 ec.Errorf(ctx, "must not be null")
13618 }
13619 return graphql.Null
13620 }
13621 return ec._CloseBugPayload(ctx, sel, v)
13622}
13623
13624func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
13625 return ec._Color(ctx, sel, &v)
13626}
13627
13628func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
13629 if v == nil {
13630 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13631 ec.Errorf(ctx, "must not be null")
13632 }
13633 return graphql.Null
13634 }
13635 return ec._Color(ctx, sel, v)
13636}
13637
13638func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
13639 return ec._Comment(ctx, sel, &v)
13640}
13641
13642func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) 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.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(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) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
13680 if v == nil {
13681 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13682 ec.Errorf(ctx, "must not be null")
13683 }
13684 return graphql.Null
13685 }
13686 return ec._Comment(ctx, sel, v)
13687}
13688
13689func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
13690 return ec._CommentConnection(ctx, sel, &v)
13691}
13692
13693func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
13694 if v == nil {
13695 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13696 ec.Errorf(ctx, "must not be null")
13697 }
13698 return graphql.Null
13699 }
13700 return ec._CommentConnection(ctx, sel, v)
13701}
13702
13703func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
13704 return ec._CommentEdge(ctx, sel, &v)
13705}
13706
13707func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
13708 ret := make(graphql.Array, len(v))
13709 var wg sync.WaitGroup
13710 isLen1 := len(v) == 1
13711 if !isLen1 {
13712 wg.Add(len(v))
13713 }
13714 for i := range v {
13715 i := i
13716 fc := &graphql.FieldContext{
13717 Index: &i,
13718 Result: &v[i],
13719 }
13720 ctx := graphql.WithFieldContext(ctx, fc)
13721 f := func(i int) {
13722 defer func() {
13723 if r := recover(); r != nil {
13724 ec.Error(ctx, ec.Recover(ctx, r))
13725 ret = nil
13726 }
13727 }()
13728 if !isLen1 {
13729 defer wg.Done()
13730 }
13731 ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
13732 }
13733 if isLen1 {
13734 f(i)
13735 } else {
13736 go f(i)
13737 }
13738
13739 }
13740 wg.Wait()
13741 return ret
13742}
13743
13744func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
13745 if v == nil {
13746 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13747 ec.Errorf(ctx, "must not be null")
13748 }
13749 return graphql.Null
13750 }
13751 return ec._CommentEdge(ctx, sel, v)
13752}
13753
13754func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
13755 return ec._CommentHistoryStep(ctx, sel, &v)
13756}
13757
13758func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
13759 ret := make(graphql.Array, len(v))
13760 var wg sync.WaitGroup
13761 isLen1 := len(v) == 1
13762 if !isLen1 {
13763 wg.Add(len(v))
13764 }
13765 for i := range v {
13766 i := i
13767 fc := &graphql.FieldContext{
13768 Index: &i,
13769 Result: &v[i],
13770 }
13771 ctx := graphql.WithFieldContext(ctx, fc)
13772 f := func(i int) {
13773 defer func() {
13774 if r := recover(); r != nil {
13775 ec.Error(ctx, ec.Recover(ctx, r))
13776 ret = nil
13777 }
13778 }()
13779 if !isLen1 {
13780 defer wg.Done()
13781 }
13782 ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
13783 }
13784 if isLen1 {
13785 f(i)
13786 } else {
13787 go f(i)
13788 }
13789
13790 }
13791 wg.Wait()
13792 return ret
13793}
13794
13795func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
13796 return ec._CreateOperation(ctx, sel, &v)
13797}
13798
13799func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
13800 if v == nil {
13801 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13802 ec.Errorf(ctx, "must not be null")
13803 }
13804 return graphql.Null
13805 }
13806 return ec._CreateOperation(ctx, sel, v)
13807}
13808
13809func (ec *executionContext) unmarshalNEditCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx context.Context, v interface{}) (models.EditCommentInput, error) {
13810 return ec.unmarshalInputEditCommentInput(ctx, v)
13811}
13812
13813func (ec *executionContext) marshalNEditCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐEditCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.EditCommentOperation) graphql.Marshaler {
13814 return ec._EditCommentOperation(ctx, sel, &v)
13815}
13816
13817func (ec *executionContext) marshalNEditCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐEditCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.EditCommentOperation) graphql.Marshaler {
13818 if v == nil {
13819 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13820 ec.Errorf(ctx, "must not be null")
13821 }
13822 return graphql.Null
13823 }
13824 return ec._EditCommentOperation(ctx, sel, v)
13825}
13826
13827func (ec *executionContext) marshalNEditCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.EditCommentPayload) graphql.Marshaler {
13828 return ec._EditCommentPayload(ctx, sel, &v)
13829}
13830
13831func (ec *executionContext) marshalNEditCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.EditCommentPayload) graphql.Marshaler {
13832 if v == nil {
13833 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13834 ec.Errorf(ctx, "must not be null")
13835 }
13836 return graphql.Null
13837 }
13838 return ec._EditCommentPayload(ctx, sel, v)
13839}
13840
13841func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx context.Context, v interface{}) (repository.Hash, error) {
13842 var res repository.Hash
13843 return res, res.UnmarshalGQL(v)
13844}
13845
13846func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx context.Context, sel ast.SelectionSet, v repository.Hash) graphql.Marshaler {
13847 return v
13848}
13849
13850func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, v interface{}) ([]repository.Hash, error) {
13851 var vSlice []interface{}
13852 if v != nil {
13853 if tmp1, ok := v.([]interface{}); ok {
13854 vSlice = tmp1
13855 } else {
13856 vSlice = []interface{}{v}
13857 }
13858 }
13859 var err error
13860 res := make([]repository.Hash, len(vSlice))
13861 for i := range vSlice {
13862 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, vSlice[i])
13863 if err != nil {
13864 return nil, err
13865 }
13866 }
13867 return res, nil
13868}
13869
13870func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []repository.Hash) graphql.Marshaler {
13871 ret := make(graphql.Array, len(v))
13872 for i := range v {
13873 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, sel, v[i])
13874 }
13875
13876 return ret
13877}
13878
13879func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
13880 if v == nil {
13881 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13882 ec.Errorf(ctx, "must not be null")
13883 }
13884 return graphql.Null
13885 }
13886 return ec._Identity(ctx, sel, v)
13887}
13888
13889func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.IdentityWrapper) graphql.Marshaler {
13890 ret := make(graphql.Array, len(v))
13891 var wg sync.WaitGroup
13892 isLen1 := len(v) == 1
13893 if !isLen1 {
13894 wg.Add(len(v))
13895 }
13896 for i := range v {
13897 i := i
13898 fc := &graphql.FieldContext{
13899 Index: &i,
13900 Result: &v[i],
13901 }
13902 ctx := graphql.WithFieldContext(ctx, fc)
13903 f := func(i int) {
13904 defer func() {
13905 if r := recover(); r != nil {
13906 ec.Error(ctx, ec.Recover(ctx, r))
13907 ret = nil
13908 }
13909 }()
13910 if !isLen1 {
13911 defer wg.Done()
13912 }
13913 ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, sel, v[i])
13914 }
13915 if isLen1 {
13916 f(i)
13917 } else {
13918 go f(i)
13919 }
13920
13921 }
13922 wg.Wait()
13923 return ret
13924}
13925
13926func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
13927 return ec._IdentityConnection(ctx, sel, &v)
13928}
13929
13930func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
13931 if v == nil {
13932 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13933 ec.Errorf(ctx, "must not be null")
13934 }
13935 return graphql.Null
13936 }
13937 return ec._IdentityConnection(ctx, sel, v)
13938}
13939
13940func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
13941 return ec._IdentityEdge(ctx, sel, &v)
13942}
13943
13944func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
13945 ret := make(graphql.Array, len(v))
13946 var wg sync.WaitGroup
13947 isLen1 := len(v) == 1
13948 if !isLen1 {
13949 wg.Add(len(v))
13950 }
13951 for i := range v {
13952 i := i
13953 fc := &graphql.FieldContext{
13954 Index: &i,
13955 Result: &v[i],
13956 }
13957 ctx := graphql.WithFieldContext(ctx, fc)
13958 f := func(i int) {
13959 defer func() {
13960 if r := recover(); r != nil {
13961 ec.Error(ctx, ec.Recover(ctx, r))
13962 ret = nil
13963 }
13964 }()
13965 if !isLen1 {
13966 defer wg.Done()
13967 }
13968 ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
13969 }
13970 if isLen1 {
13971 f(i)
13972 } else {
13973 go f(i)
13974 }
13975
13976 }
13977 wg.Wait()
13978 return ret
13979}
13980
13981func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
13982 if v == nil {
13983 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13984 ec.Errorf(ctx, "must not be null")
13985 }
13986 return graphql.Null
13987 }
13988 return ec._IdentityEdge(ctx, sel, v)
13989}
13990
13991func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
13992 return graphql.UnmarshalInt(v)
13993}
13994
13995func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
13996 res := graphql.MarshalInt(v)
13997 if res == graphql.Null {
13998 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13999 ec.Errorf(ctx, "must not be null")
14000 }
14001 }
14002 return res
14003}
14004
14005func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
14006 return ec._Label(ctx, sel, &v)
14007}
14008
14009func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
14010 ret := make(graphql.Array, len(v))
14011 var wg sync.WaitGroup
14012 isLen1 := len(v) == 1
14013 if !isLen1 {
14014 wg.Add(len(v))
14015 }
14016 for i := range v {
14017 i := i
14018 fc := &graphql.FieldContext{
14019 Index: &i,
14020 Result: &v[i],
14021 }
14022 ctx := graphql.WithFieldContext(ctx, fc)
14023 f := func(i int) {
14024 defer func() {
14025 if r := recover(); r != nil {
14026 ec.Error(ctx, ec.Recover(ctx, r))
14027 ret = nil
14028 }
14029 }()
14030 if !isLen1 {
14031 defer wg.Done()
14032 }
14033 ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
14034 }
14035 if isLen1 {
14036 f(i)
14037 } else {
14038 go f(i)
14039 }
14040
14041 }
14042 wg.Wait()
14043 return ret
14044}
14045
14046func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
14047 return ec._LabelChangeOperation(ctx, sel, &v)
14048}
14049
14050func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
14051 if v == nil {
14052 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14053 ec.Errorf(ctx, "must not be null")
14054 }
14055 return graphql.Null
14056 }
14057 return ec._LabelChangeOperation(ctx, sel, v)
14058}
14059
14060func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
14061 ret := make(graphql.Array, len(v))
14062 var wg sync.WaitGroup
14063 isLen1 := len(v) == 1
14064 if !isLen1 {
14065 wg.Add(len(v))
14066 }
14067 for i := range v {
14068 i := i
14069 fc := &graphql.FieldContext{
14070 Index: &i,
14071 Result: &v[i],
14072 }
14073 ctx := graphql.WithFieldContext(ctx, fc)
14074 f := func(i int) {
14075 defer func() {
14076 if r := recover(); r != nil {
14077 ec.Error(ctx, ec.Recover(ctx, r))
14078 ret = nil
14079 }
14080 }()
14081 if !isLen1 {
14082 defer wg.Done()
14083 }
14084 ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
14085 }
14086 if isLen1 {
14087 f(i)
14088 } else {
14089 go f(i)
14090 }
14091
14092 }
14093 wg.Wait()
14094 return ret
14095}
14096
14097func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
14098 var res models.LabelChangeStatus
14099 return res, res.UnmarshalGQL(v)
14100}
14101
14102func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
14103 return v
14104}
14105
14106func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
14107 return ec._LabelConnection(ctx, sel, &v)
14108}
14109
14110func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
14111 if v == nil {
14112 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14113 ec.Errorf(ctx, "must not be null")
14114 }
14115 return graphql.Null
14116 }
14117 return ec._LabelConnection(ctx, sel, v)
14118}
14119
14120func (ec *executionContext) marshalNLabelEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v models.LabelEdge) graphql.Marshaler {
14121 return ec._LabelEdge(ctx, sel, &v)
14122}
14123
14124func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
14125 ret := make(graphql.Array, len(v))
14126 var wg sync.WaitGroup
14127 isLen1 := len(v) == 1
14128 if !isLen1 {
14129 wg.Add(len(v))
14130 }
14131 for i := range v {
14132 i := i
14133 fc := &graphql.FieldContext{
14134 Index: &i,
14135 Result: &v[i],
14136 }
14137 ctx := graphql.WithFieldContext(ctx, fc)
14138 f := func(i int) {
14139 defer func() {
14140 if r := recover(); r != nil {
14141 ec.Error(ctx, ec.Recover(ctx, r))
14142 ret = nil
14143 }
14144 }()
14145 if !isLen1 {
14146 defer wg.Done()
14147 }
14148 ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
14149 }
14150 if isLen1 {
14151 f(i)
14152 } else {
14153 go f(i)
14154 }
14155
14156 }
14157 wg.Wait()
14158 return ret
14159}
14160
14161func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
14162 if v == nil {
14163 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14164 ec.Errorf(ctx, "must not be null")
14165 }
14166 return graphql.Null
14167 }
14168 return ec._LabelEdge(ctx, sel, v)
14169}
14170
14171func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
14172 return ec.unmarshalInputNewBugInput(ctx, v)
14173}
14174
14175func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
14176 return ec._NewBugPayload(ctx, sel, &v)
14177}
14178
14179func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
14180 if v == nil {
14181 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14182 ec.Errorf(ctx, "must not be null")
14183 }
14184 return graphql.Null
14185 }
14186 return ec._NewBugPayload(ctx, sel, v)
14187}
14188
14189func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
14190 return ec.unmarshalInputOpenBugInput(ctx, v)
14191}
14192
14193func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
14194 return ec._OpenBugPayload(ctx, sel, &v)
14195}
14196
14197func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
14198 if v == nil {
14199 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14200 ec.Errorf(ctx, "must not be null")
14201 }
14202 return graphql.Null
14203 }
14204 return ec._OpenBugPayload(ctx, sel, v)
14205}
14206
14207func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
14208 if v == nil {
14209 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14210 ec.Errorf(ctx, "must not be null")
14211 }
14212 return graphql.Null
14213 }
14214 return ec._Operation(ctx, sel, v)
14215}
14216
14217func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
14218 ret := make(graphql.Array, len(v))
14219 var wg sync.WaitGroup
14220 isLen1 := len(v) == 1
14221 if !isLen1 {
14222 wg.Add(len(v))
14223 }
14224 for i := range v {
14225 i := i
14226 fc := &graphql.FieldContext{
14227 Index: &i,
14228 Result: &v[i],
14229 }
14230 ctx := graphql.WithFieldContext(ctx, fc)
14231 f := func(i int) {
14232 defer func() {
14233 if r := recover(); r != nil {
14234 ec.Error(ctx, ec.Recover(ctx, r))
14235 ret = nil
14236 }
14237 }()
14238 if !isLen1 {
14239 defer wg.Done()
14240 }
14241 ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
14242 }
14243 if isLen1 {
14244 f(i)
14245 } else {
14246 go f(i)
14247 }
14248
14249 }
14250 wg.Wait()
14251 return ret
14252}
14253
14254func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
14255 return ec._OperationConnection(ctx, sel, &v)
14256}
14257
14258func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
14259 if v == nil {
14260 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14261 ec.Errorf(ctx, "must not be null")
14262 }
14263 return graphql.Null
14264 }
14265 return ec._OperationConnection(ctx, sel, v)
14266}
14267
14268func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
14269 return ec._OperationEdge(ctx, sel, &v)
14270}
14271
14272func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
14273 ret := make(graphql.Array, len(v))
14274 var wg sync.WaitGroup
14275 isLen1 := len(v) == 1
14276 if !isLen1 {
14277 wg.Add(len(v))
14278 }
14279 for i := range v {
14280 i := i
14281 fc := &graphql.FieldContext{
14282 Index: &i,
14283 Result: &v[i],
14284 }
14285 ctx := graphql.WithFieldContext(ctx, fc)
14286 f := func(i int) {
14287 defer func() {
14288 if r := recover(); r != nil {
14289 ec.Error(ctx, ec.Recover(ctx, r))
14290 ret = nil
14291 }
14292 }()
14293 if !isLen1 {
14294 defer wg.Done()
14295 }
14296 ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
14297 }
14298 if isLen1 {
14299 f(i)
14300 } else {
14301 go f(i)
14302 }
14303
14304 }
14305 wg.Wait()
14306 return ret
14307}
14308
14309func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
14310 if v == nil {
14311 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14312 ec.Errorf(ctx, "must not be null")
14313 }
14314 return graphql.Null
14315 }
14316 return ec._OperationEdge(ctx, sel, v)
14317}
14318
14319func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
14320 return ec._PageInfo(ctx, sel, &v)
14321}
14322
14323func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
14324 if v == nil {
14325 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14326 ec.Errorf(ctx, "must not be null")
14327 }
14328 return graphql.Null
14329 }
14330 return ec._PageInfo(ctx, sel, v)
14331}
14332
14333func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
14334 return ec._SetStatusOperation(ctx, sel, &v)
14335}
14336
14337func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
14338 if v == nil {
14339 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14340 ec.Errorf(ctx, "must not be null")
14341 }
14342 return graphql.Null
14343 }
14344 return ec._SetStatusOperation(ctx, sel, v)
14345}
14346
14347func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
14348 return ec.unmarshalInputSetTitleInput(ctx, v)
14349}
14350
14351func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
14352 return ec._SetTitleOperation(ctx, sel, &v)
14353}
14354
14355func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
14356 if v == nil {
14357 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14358 ec.Errorf(ctx, "must not be null")
14359 }
14360 return graphql.Null
14361 }
14362 return ec._SetTitleOperation(ctx, sel, v)
14363}
14364
14365func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
14366 return ec._SetTitlePayload(ctx, sel, &v)
14367}
14368
14369func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
14370 if v == nil {
14371 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14372 ec.Errorf(ctx, "must not be null")
14373 }
14374 return graphql.Null
14375 }
14376 return ec._SetTitlePayload(ctx, sel, v)
14377}
14378
14379func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
14380 var res models.Status
14381 return res, res.UnmarshalGQL(v)
14382}
14383
14384func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
14385 return v
14386}
14387
14388func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
14389 return graphql.UnmarshalString(v)
14390}
14391
14392func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14393 res := graphql.MarshalString(v)
14394 if res == graphql.Null {
14395 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14396 ec.Errorf(ctx, "must not be null")
14397 }
14398 }
14399 return res
14400}
14401
14402func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
14403 return graphql.UnmarshalTime(v)
14404}
14405
14406func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
14407 res := graphql.MarshalTime(v)
14408 if res == graphql.Null {
14409 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14410 ec.Errorf(ctx, "must not be null")
14411 }
14412 }
14413 return res
14414}
14415
14416func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
14417 if v == nil {
14418 return nil, nil
14419 }
14420 res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
14421 return &res, err
14422}
14423
14424func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
14425 if v == nil {
14426 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14427 ec.Errorf(ctx, "must not be null")
14428 }
14429 return graphql.Null
14430 }
14431 return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
14432}
14433
14434func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
14435 if v == nil {
14436 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14437 ec.Errorf(ctx, "must not be null")
14438 }
14439 return graphql.Null
14440 }
14441 return ec._TimelineItem(ctx, sel, v)
14442}
14443
14444func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
14445 ret := make(graphql.Array, len(v))
14446 var wg sync.WaitGroup
14447 isLen1 := len(v) == 1
14448 if !isLen1 {
14449 wg.Add(len(v))
14450 }
14451 for i := range v {
14452 i := i
14453 fc := &graphql.FieldContext{
14454 Index: &i,
14455 Result: &v[i],
14456 }
14457 ctx := graphql.WithFieldContext(ctx, fc)
14458 f := func(i int) {
14459 defer func() {
14460 if r := recover(); r != nil {
14461 ec.Error(ctx, ec.Recover(ctx, r))
14462 ret = nil
14463 }
14464 }()
14465 if !isLen1 {
14466 defer wg.Done()
14467 }
14468 ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
14469 }
14470 if isLen1 {
14471 f(i)
14472 } else {
14473 go f(i)
14474 }
14475
14476 }
14477 wg.Wait()
14478 return ret
14479}
14480
14481func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
14482 return ec._TimelineItemConnection(ctx, sel, &v)
14483}
14484
14485func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
14486 if v == nil {
14487 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14488 ec.Errorf(ctx, "must not be null")
14489 }
14490 return graphql.Null
14491 }
14492 return ec._TimelineItemConnection(ctx, sel, v)
14493}
14494
14495func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
14496 return ec._TimelineItemEdge(ctx, sel, &v)
14497}
14498
14499func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
14500 ret := make(graphql.Array, len(v))
14501 var wg sync.WaitGroup
14502 isLen1 := len(v) == 1
14503 if !isLen1 {
14504 wg.Add(len(v))
14505 }
14506 for i := range v {
14507 i := i
14508 fc := &graphql.FieldContext{
14509 Index: &i,
14510 Result: &v[i],
14511 }
14512 ctx := graphql.WithFieldContext(ctx, fc)
14513 f := func(i int) {
14514 defer func() {
14515 if r := recover(); r != nil {
14516 ec.Error(ctx, ec.Recover(ctx, r))
14517 ret = nil
14518 }
14519 }()
14520 if !isLen1 {
14521 defer wg.Done()
14522 }
14523 ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
14524 }
14525 if isLen1 {
14526 f(i)
14527 } else {
14528 go f(i)
14529 }
14530
14531 }
14532 wg.Wait()
14533 return ret
14534}
14535
14536func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
14537 if v == nil {
14538 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14539 ec.Errorf(ctx, "must not be null")
14540 }
14541 return graphql.Null
14542 }
14543 return ec._TimelineItemEdge(ctx, sel, v)
14544}
14545
14546func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
14547 return ec.___Directive(ctx, sel, &v)
14548}
14549
14550func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
14551 ret := make(graphql.Array, len(v))
14552 var wg sync.WaitGroup
14553 isLen1 := len(v) == 1
14554 if !isLen1 {
14555 wg.Add(len(v))
14556 }
14557 for i := range v {
14558 i := i
14559 fc := &graphql.FieldContext{
14560 Index: &i,
14561 Result: &v[i],
14562 }
14563 ctx := graphql.WithFieldContext(ctx, fc)
14564 f := func(i int) {
14565 defer func() {
14566 if r := recover(); r != nil {
14567 ec.Error(ctx, ec.Recover(ctx, r))
14568 ret = nil
14569 }
14570 }()
14571 if !isLen1 {
14572 defer wg.Done()
14573 }
14574 ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
14575 }
14576 if isLen1 {
14577 f(i)
14578 } else {
14579 go f(i)
14580 }
14581
14582 }
14583 wg.Wait()
14584 return ret
14585}
14586
14587func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
14588 return graphql.UnmarshalString(v)
14589}
14590
14591func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14592 res := graphql.MarshalString(v)
14593 if res == graphql.Null {
14594 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14595 ec.Errorf(ctx, "must not be null")
14596 }
14597 }
14598 return res
14599}
14600
14601func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14602 var vSlice []interface{}
14603 if v != nil {
14604 if tmp1, ok := v.([]interface{}); ok {
14605 vSlice = tmp1
14606 } else {
14607 vSlice = []interface{}{v}
14608 }
14609 }
14610 var err error
14611 res := make([]string, len(vSlice))
14612 for i := range vSlice {
14613 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
14614 if err != nil {
14615 return nil, err
14616 }
14617 }
14618 return res, nil
14619}
14620
14621func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14622 ret := make(graphql.Array, len(v))
14623 var wg sync.WaitGroup
14624 isLen1 := len(v) == 1
14625 if !isLen1 {
14626 wg.Add(len(v))
14627 }
14628 for i := range v {
14629 i := i
14630 fc := &graphql.FieldContext{
14631 Index: &i,
14632 Result: &v[i],
14633 }
14634 ctx := graphql.WithFieldContext(ctx, fc)
14635 f := func(i int) {
14636 defer func() {
14637 if r := recover(); r != nil {
14638 ec.Error(ctx, ec.Recover(ctx, r))
14639 ret = nil
14640 }
14641 }()
14642 if !isLen1 {
14643 defer wg.Done()
14644 }
14645 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
14646 }
14647 if isLen1 {
14648 f(i)
14649 } else {
14650 go f(i)
14651 }
14652
14653 }
14654 wg.Wait()
14655 return ret
14656}
14657
14658func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
14659 return ec.___EnumValue(ctx, sel, &v)
14660}
14661
14662func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
14663 return ec.___Field(ctx, sel, &v)
14664}
14665
14666func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
14667 return ec.___InputValue(ctx, sel, &v)
14668}
14669
14670func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14671 ret := make(graphql.Array, len(v))
14672 var wg sync.WaitGroup
14673 isLen1 := len(v) == 1
14674 if !isLen1 {
14675 wg.Add(len(v))
14676 }
14677 for i := range v {
14678 i := i
14679 fc := &graphql.FieldContext{
14680 Index: &i,
14681 Result: &v[i],
14682 }
14683 ctx := graphql.WithFieldContext(ctx, fc)
14684 f := func(i int) {
14685 defer func() {
14686 if r := recover(); r != nil {
14687 ec.Error(ctx, ec.Recover(ctx, r))
14688 ret = nil
14689 }
14690 }()
14691 if !isLen1 {
14692 defer wg.Done()
14693 }
14694 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14695 }
14696 if isLen1 {
14697 f(i)
14698 } else {
14699 go f(i)
14700 }
14701
14702 }
14703 wg.Wait()
14704 return ret
14705}
14706
14707func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14708 return ec.___Type(ctx, sel, &v)
14709}
14710
14711func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14712 ret := make(graphql.Array, len(v))
14713 var wg sync.WaitGroup
14714 isLen1 := len(v) == 1
14715 if !isLen1 {
14716 wg.Add(len(v))
14717 }
14718 for i := range v {
14719 i := i
14720 fc := &graphql.FieldContext{
14721 Index: &i,
14722 Result: &v[i],
14723 }
14724 ctx := graphql.WithFieldContext(ctx, fc)
14725 f := func(i int) {
14726 defer func() {
14727 if r := recover(); r != nil {
14728 ec.Error(ctx, ec.Recover(ctx, r))
14729 ret = nil
14730 }
14731 }()
14732 if !isLen1 {
14733 defer wg.Done()
14734 }
14735 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14736 }
14737 if isLen1 {
14738 f(i)
14739 } else {
14740 go f(i)
14741 }
14742
14743 }
14744 wg.Wait()
14745 return ret
14746}
14747
14748func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14749 if v == nil {
14750 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14751 ec.Errorf(ctx, "must not be null")
14752 }
14753 return graphql.Null
14754 }
14755 return ec.___Type(ctx, sel, v)
14756}
14757
14758func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
14759 return graphql.UnmarshalString(v)
14760}
14761
14762func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14763 res := graphql.MarshalString(v)
14764 if res == graphql.Null {
14765 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14766 ec.Errorf(ctx, "must not be null")
14767 }
14768 }
14769 return res
14770}
14771
14772func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
14773 return graphql.UnmarshalBoolean(v)
14774}
14775
14776func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
14777 return graphql.MarshalBoolean(v)
14778}
14779
14780func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
14781 if v == nil {
14782 return nil, nil
14783 }
14784 res, err := ec.unmarshalOBoolean2bool(ctx, v)
14785 return &res, err
14786}
14787
14788func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
14789 if v == nil {
14790 return graphql.Null
14791 }
14792 return ec.marshalOBoolean2bool(ctx, sel, *v)
14793}
14794
14795func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
14796 if v == nil {
14797 return graphql.Null
14798 }
14799 return ec._Bug(ctx, sel, v)
14800}
14801
14802func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
14803 return ec.unmarshalInputChangeLabelInput(ctx, v)
14804}
14805
14806func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
14807 if v == nil {
14808 return nil, nil
14809 }
14810 res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
14811 return &res, err
14812}
14813
14814func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, v interface{}) ([]repository.Hash, error) {
14815 var vSlice []interface{}
14816 if v != nil {
14817 if tmp1, ok := v.([]interface{}); ok {
14818 vSlice = tmp1
14819 } else {
14820 vSlice = []interface{}{v}
14821 }
14822 }
14823 var err error
14824 res := make([]repository.Hash, len(vSlice))
14825 for i := range vSlice {
14826 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, vSlice[i])
14827 if err != nil {
14828 return nil, err
14829 }
14830 }
14831 return res, nil
14832}
14833
14834func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []repository.Hash) graphql.Marshaler {
14835 if v == nil {
14836 return graphql.Null
14837 }
14838 ret := make(graphql.Array, len(v))
14839 for i := range v {
14840 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, sel, v[i])
14841 }
14842
14843 return ret
14844}
14845
14846func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
14847 if v == nil {
14848 return graphql.Null
14849 }
14850 return ec._Identity(ctx, sel, v)
14851}
14852
14853func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
14854 return graphql.UnmarshalInt(v)
14855}
14856
14857func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14858 return graphql.MarshalInt(v)
14859}
14860
14861func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
14862 if v == nil {
14863 return nil, nil
14864 }
14865 res, err := ec.unmarshalOInt2int(ctx, v)
14866 return &res, err
14867}
14868
14869func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
14870 if v == nil {
14871 return graphql.Null
14872 }
14873 return ec.marshalOInt2int(ctx, sel, *v)
14874}
14875
14876func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
14877 return ec._LabelChangeResult(ctx, sel, &v)
14878}
14879
14880func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
14881 if v == nil {
14882 return graphql.Null
14883 }
14884 return ec._LabelChangeResult(ctx, sel, v)
14885}
14886
14887func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
14888 return ec._Repository(ctx, sel, &v)
14889}
14890
14891func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
14892 if v == nil {
14893 return graphql.Null
14894 }
14895 return ec._Repository(ctx, sel, v)
14896}
14897
14898func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
14899 return graphql.UnmarshalString(v)
14900}
14901
14902func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14903 return graphql.MarshalString(v)
14904}
14905
14906func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14907 var vSlice []interface{}
14908 if v != nil {
14909 if tmp1, ok := v.([]interface{}); ok {
14910 vSlice = tmp1
14911 } else {
14912 vSlice = []interface{}{v}
14913 }
14914 }
14915 var err error
14916 res := make([]string, len(vSlice))
14917 for i := range vSlice {
14918 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
14919 if err != nil {
14920 return nil, err
14921 }
14922 }
14923 return res, nil
14924}
14925
14926func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14927 if v == nil {
14928 return graphql.Null
14929 }
14930 ret := make(graphql.Array, len(v))
14931 for i := range v {
14932 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
14933 }
14934
14935 return ret
14936}
14937
14938func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
14939 if v == nil {
14940 return nil, nil
14941 }
14942 res, err := ec.unmarshalOString2string(ctx, v)
14943 return &res, err
14944}
14945
14946func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
14947 if v == nil {
14948 return graphql.Null
14949 }
14950 return ec.marshalOString2string(ctx, sel, *v)
14951}
14952
14953func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
14954 if v == nil {
14955 return graphql.Null
14956 }
14957 ret := make(graphql.Array, len(v))
14958 var wg sync.WaitGroup
14959 isLen1 := len(v) == 1
14960 if !isLen1 {
14961 wg.Add(len(v))
14962 }
14963 for i := range v {
14964 i := i
14965 fc := &graphql.FieldContext{
14966 Index: &i,
14967 Result: &v[i],
14968 }
14969 ctx := graphql.WithFieldContext(ctx, fc)
14970 f := func(i int) {
14971 defer func() {
14972 if r := recover(); r != nil {
14973 ec.Error(ctx, ec.Recover(ctx, r))
14974 ret = nil
14975 }
14976 }()
14977 if !isLen1 {
14978 defer wg.Done()
14979 }
14980 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
14981 }
14982 if isLen1 {
14983 f(i)
14984 } else {
14985 go f(i)
14986 }
14987
14988 }
14989 wg.Wait()
14990 return ret
14991}
14992
14993func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
14994 if v == nil {
14995 return graphql.Null
14996 }
14997 ret := make(graphql.Array, len(v))
14998 var wg sync.WaitGroup
14999 isLen1 := len(v) == 1
15000 if !isLen1 {
15001 wg.Add(len(v))
15002 }
15003 for i := range v {
15004 i := i
15005 fc := &graphql.FieldContext{
15006 Index: &i,
15007 Result: &v[i],
15008 }
15009 ctx := graphql.WithFieldContext(ctx, fc)
15010 f := func(i int) {
15011 defer func() {
15012 if r := recover(); r != nil {
15013 ec.Error(ctx, ec.Recover(ctx, r))
15014 ret = nil
15015 }
15016 }()
15017 if !isLen1 {
15018 defer wg.Done()
15019 }
15020 ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
15021 }
15022 if isLen1 {
15023 f(i)
15024 } else {
15025 go f(i)
15026 }
15027
15028 }
15029 wg.Wait()
15030 return ret
15031}
15032
15033func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
15034 if v == nil {
15035 return graphql.Null
15036 }
15037 ret := make(graphql.Array, len(v))
15038 var wg sync.WaitGroup
15039 isLen1 := len(v) == 1
15040 if !isLen1 {
15041 wg.Add(len(v))
15042 }
15043 for i := range v {
15044 i := i
15045 fc := &graphql.FieldContext{
15046 Index: &i,
15047 Result: &v[i],
15048 }
15049 ctx := graphql.WithFieldContext(ctx, fc)
15050 f := func(i int) {
15051 defer func() {
15052 if r := recover(); r != nil {
15053 ec.Error(ctx, ec.Recover(ctx, r))
15054 ret = nil
15055 }
15056 }()
15057 if !isLen1 {
15058 defer wg.Done()
15059 }
15060 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
15061 }
15062 if isLen1 {
15063 f(i)
15064 } else {
15065 go f(i)
15066 }
15067
15068 }
15069 wg.Wait()
15070 return ret
15071}
15072
15073func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
15074 return ec.___Schema(ctx, sel, &v)
15075}
15076
15077func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
15078 if v == nil {
15079 return graphql.Null
15080 }
15081 return ec.___Schema(ctx, sel, v)
15082}
15083
15084func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
15085 return ec.___Type(ctx, sel, &v)
15086}
15087
15088func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
15089 if v == nil {
15090 return graphql.Null
15091 }
15092 ret := make(graphql.Array, len(v))
15093 var wg sync.WaitGroup
15094 isLen1 := len(v) == 1
15095 if !isLen1 {
15096 wg.Add(len(v))
15097 }
15098 for i := range v {
15099 i := i
15100 fc := &graphql.FieldContext{
15101 Index: &i,
15102 Result: &v[i],
15103 }
15104 ctx := graphql.WithFieldContext(ctx, fc)
15105 f := func(i int) {
15106 defer func() {
15107 if r := recover(); r != nil {
15108 ec.Error(ctx, ec.Recover(ctx, r))
15109 ret = nil
15110 }
15111 }()
15112 if !isLen1 {
15113 defer wg.Done()
15114 }
15115 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
15116 }
15117 if isLen1 {
15118 f(i)
15119 } else {
15120 go f(i)
15121 }
15122
15123 }
15124 wg.Wait()
15125 return ret
15126}
15127
15128func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
15129 if v == nil {
15130 return graphql.Null
15131 }
15132 return ec.___Type(ctx, sel, v)
15133}
15134
15135// endregion ***************************** type.gotpl *****************************