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/entity/dag"
21 "github.com/MichaelMure/git-bug/repository"
22 gqlparser "github.com/vektah/gqlparser/v2"
23 "github.com/vektah/gqlparser/v2/ast"
24)
25
26// region ************************** generated!.gotpl **************************
27
28// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
29func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
30 return &executableSchema{
31 resolvers: cfg.Resolvers,
32 directives: cfg.Directives,
33 complexity: cfg.Complexity,
34 }
35}
36
37type Config struct {
38 Resolvers ResolverRoot
39 Directives DirectiveRoot
40 Complexity ComplexityRoot
41}
42
43type ResolverRoot interface {
44 AddCommentOperation() AddCommentOperationResolver
45 AddCommentTimelineItem() AddCommentTimelineItemResolver
46 Bug() BugResolver
47 Color() ColorResolver
48 Comment() CommentResolver
49 CommentHistoryStep() CommentHistoryStepResolver
50 CreateOperation() CreateOperationResolver
51 CreateTimelineItem() CreateTimelineItemResolver
52 EditCommentOperation() EditCommentOperationResolver
53 Identity() IdentityResolver
54 Label() LabelResolver
55 LabelChangeOperation() LabelChangeOperationResolver
56 LabelChangeResult() LabelChangeResultResolver
57 LabelChangeTimelineItem() LabelChangeTimelineItemResolver
58 Mutation() MutationResolver
59 Query() QueryResolver
60 Repository() RepositoryResolver
61 SetStatusOperation() SetStatusOperationResolver
62 SetStatusTimelineItem() SetStatusTimelineItemResolver
63 SetTitleOperation() SetTitleOperationResolver
64 SetTitleTimelineItem() SetTitleTimelineItemResolver
65}
66
67type DirectiveRoot struct {
68}
69
70type ComplexityRoot struct {
71 AddCommentAndCloseBugPayload struct {
72 Bug func(childComplexity int) int
73 ClientMutationID func(childComplexity int) int
74 CommentOperation func(childComplexity int) int
75 StatusOperation func(childComplexity int) int
76 }
77
78 AddCommentAndReopenBugPayload struct {
79 Bug func(childComplexity int) int
80 ClientMutationID func(childComplexity int) int
81 CommentOperation func(childComplexity int) int
82 StatusOperation func(childComplexity int) int
83 }
84
85 AddCommentOperation struct {
86 Author func(childComplexity int) int
87 Date func(childComplexity int) int
88 Files func(childComplexity int) int
89 ID func(childComplexity int) int
90 Message func(childComplexity int) int
91 }
92
93 AddCommentPayload struct {
94 Bug func(childComplexity int) int
95 ClientMutationID func(childComplexity int) int
96 Operation func(childComplexity int) int
97 }
98
99 AddCommentTimelineItem struct {
100 Author func(childComplexity int) int
101 CreatedAt func(childComplexity int) int
102 Edited func(childComplexity int) int
103 Files func(childComplexity int) int
104 History func(childComplexity int) int
105 ID func(childComplexity int) int
106 LastEdit func(childComplexity int) int
107 Message func(childComplexity int) int
108 MessageIsEmpty func(childComplexity int) int
109 }
110
111 Bug struct {
112 Actors func(childComplexity int, after *string, before *string, first *int, last *int) int
113 Author func(childComplexity int) int
114 Comments func(childComplexity int, after *string, before *string, first *int, last *int) int
115 CreatedAt func(childComplexity int) int
116 HumanID func(childComplexity int) int
117 ID func(childComplexity int) int
118 Labels func(childComplexity int) int
119 LastEdit func(childComplexity int) int
120 Operations func(childComplexity int, after *string, before *string, first *int, last *int) int
121 Participants func(childComplexity int, after *string, before *string, first *int, last *int) int
122 Status func(childComplexity int) int
123 Timeline func(childComplexity int, after *string, before *string, first *int, last *int) int
124 Title func(childComplexity int) int
125 }
126
127 BugConnection struct {
128 Edges func(childComplexity int) int
129 Nodes func(childComplexity int) int
130 PageInfo func(childComplexity int) int
131 TotalCount func(childComplexity int) int
132 }
133
134 BugEdge struct {
135 Cursor func(childComplexity int) int
136 Node func(childComplexity int) int
137 }
138
139 ChangeLabelPayload struct {
140 Bug func(childComplexity int) int
141 ClientMutationID func(childComplexity int) int
142 Operation func(childComplexity int) int
143 Results func(childComplexity int) int
144 }
145
146 CloseBugPayload struct {
147 Bug func(childComplexity int) int
148 ClientMutationID func(childComplexity int) int
149 Operation func(childComplexity int) int
150 }
151
152 Color struct {
153 B func(childComplexity int) int
154 G func(childComplexity int) int
155 R func(childComplexity int) int
156 }
157
158 Comment struct {
159 Author func(childComplexity int) int
160 Files func(childComplexity int) int
161 Message func(childComplexity int) int
162 }
163
164 CommentConnection struct {
165 Edges func(childComplexity int) int
166 Nodes func(childComplexity int) int
167 PageInfo func(childComplexity int) int
168 TotalCount func(childComplexity int) int
169 }
170
171 CommentEdge struct {
172 Cursor func(childComplexity int) int
173 Node func(childComplexity int) int
174 }
175
176 CommentHistoryStep struct {
177 Date func(childComplexity int) int
178 Message func(childComplexity int) int
179 }
180
181 CreateOperation struct {
182 Author func(childComplexity int) int
183 Date func(childComplexity int) int
184 Files func(childComplexity int) int
185 ID func(childComplexity int) int
186 Message func(childComplexity int) int
187 Title func(childComplexity int) int
188 }
189
190 CreateTimelineItem struct {
191 Author func(childComplexity int) int
192 CreatedAt func(childComplexity int) int
193 Edited func(childComplexity int) int
194 Files func(childComplexity int) int
195 History func(childComplexity int) int
196 ID func(childComplexity int) int
197 LastEdit func(childComplexity int) int
198 Message func(childComplexity int) int
199 MessageIsEmpty func(childComplexity int) int
200 }
201
202 EditCommentOperation struct {
203 Author func(childComplexity int) int
204 Date func(childComplexity int) int
205 Files func(childComplexity int) int
206 ID func(childComplexity int) int
207 Message func(childComplexity int) int
208 Target func(childComplexity int) int
209 }
210
211 EditCommentPayload struct {
212 Bug func(childComplexity int) int
213 ClientMutationID func(childComplexity int) int
214 Operation func(childComplexity int) int
215 }
216
217 Identity struct {
218 AvatarUrl func(childComplexity int) int
219 DisplayName func(childComplexity int) int
220 Email func(childComplexity int) int
221 HumanID func(childComplexity int) int
222 ID func(childComplexity int) int
223 IsProtected func(childComplexity int) int
224 Login func(childComplexity int) int
225 Name func(childComplexity int) int
226 }
227
228 IdentityConnection struct {
229 Edges func(childComplexity int) int
230 Nodes func(childComplexity int) int
231 PageInfo func(childComplexity int) int
232 TotalCount func(childComplexity int) int
233 }
234
235 IdentityEdge struct {
236 Cursor func(childComplexity int) int
237 Node func(childComplexity int) int
238 }
239
240 Label struct {
241 Color func(childComplexity int) int
242 Name func(childComplexity int) int
243 }
244
245 LabelChangeOperation struct {
246 Added func(childComplexity int) int
247 Author func(childComplexity int) int
248 Date func(childComplexity int) int
249 ID func(childComplexity int) int
250 Removed func(childComplexity int) int
251 }
252
253 LabelChangeResult struct {
254 Label func(childComplexity int) int
255 Status func(childComplexity int) int
256 }
257
258 LabelChangeTimelineItem struct {
259 Added func(childComplexity int) int
260 Author func(childComplexity int) int
261 Date func(childComplexity int) int
262 ID func(childComplexity int) int
263 Removed func(childComplexity int) int
264 }
265
266 LabelConnection struct {
267 Edges func(childComplexity int) int
268 Nodes func(childComplexity int) int
269 PageInfo func(childComplexity int) int
270 TotalCount func(childComplexity int) int
271 }
272
273 LabelEdge struct {
274 Cursor func(childComplexity int) int
275 Node func(childComplexity int) int
276 }
277
278 Mutation struct {
279 AddComment func(childComplexity int, input models.AddCommentInput) int
280 AddCommentAndClose func(childComplexity int, input models.AddCommentAndCloseBugInput) int
281 AddCommentAndReopen func(childComplexity int, input models.AddCommentAndReopenBugInput) int
282 ChangeLabels func(childComplexity int, input *models.ChangeLabelInput) int
283 CloseBug func(childComplexity int, input models.CloseBugInput) int
284 EditComment func(childComplexity int, input models.EditCommentInput) int
285 NewBug func(childComplexity int, input models.NewBugInput) int
286 OpenBug func(childComplexity int, input models.OpenBugInput) int
287 SetTitle func(childComplexity int, input models.SetTitleInput) int
288 }
289
290 NewBugPayload struct {
291 Bug func(childComplexity int) int
292 ClientMutationID func(childComplexity int) int
293 Operation func(childComplexity int) int
294 }
295
296 OpenBugPayload struct {
297 Bug func(childComplexity int) int
298 ClientMutationID func(childComplexity int) int
299 Operation func(childComplexity int) int
300 }
301
302 OperationConnection struct {
303 Edges func(childComplexity int) int
304 Nodes func(childComplexity int) int
305 PageInfo func(childComplexity int) int
306 TotalCount func(childComplexity int) int
307 }
308
309 OperationEdge struct {
310 Cursor func(childComplexity int) int
311 Node func(childComplexity int) int
312 }
313
314 PageInfo struct {
315 EndCursor func(childComplexity int) int
316 HasNextPage func(childComplexity int) int
317 HasPreviousPage func(childComplexity int) int
318 StartCursor func(childComplexity int) int
319 }
320
321 Query struct {
322 Repository func(childComplexity int, ref *string) int
323 }
324
325 Repository struct {
326 AllBugs func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
327 AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
328 Bug func(childComplexity int, prefix string) int
329 Identity func(childComplexity int, prefix string) int
330 Name func(childComplexity int) int
331 UserIdentity func(childComplexity int) int
332 ValidLabels func(childComplexity int, after *string, before *string, first *int, last *int) int
333 }
334
335 SetStatusOperation struct {
336 Author func(childComplexity int) int
337 Date func(childComplexity int) int
338 ID func(childComplexity int) int
339 Status func(childComplexity int) int
340 }
341
342 SetStatusTimelineItem struct {
343 Author func(childComplexity int) int
344 Date func(childComplexity int) int
345 ID func(childComplexity int) int
346 Status func(childComplexity int) int
347 }
348
349 SetTitleOperation struct {
350 Author func(childComplexity int) int
351 Date func(childComplexity int) int
352 ID func(childComplexity int) int
353 Title func(childComplexity int) int
354 Was func(childComplexity int) int
355 }
356
357 SetTitlePayload struct {
358 Bug func(childComplexity int) int
359 ClientMutationID func(childComplexity int) int
360 Operation func(childComplexity int) int
361 }
362
363 SetTitleTimelineItem struct {
364 Author func(childComplexity int) int
365 Date func(childComplexity int) int
366 ID func(childComplexity int) int
367 Title func(childComplexity int) int
368 Was func(childComplexity int) int
369 }
370
371 TimelineItemConnection struct {
372 Edges func(childComplexity int) int
373 Nodes func(childComplexity int) int
374 PageInfo func(childComplexity int) int
375 TotalCount func(childComplexity int) int
376 }
377
378 TimelineItemEdge struct {
379 Cursor func(childComplexity int) int
380 Node func(childComplexity int) int
381 }
382}
383
384type AddCommentOperationResolver interface {
385 ID(ctx context.Context, obj *bug.AddCommentOperation) (string, error)
386 Author(ctx context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error)
387 Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
388}
389type AddCommentTimelineItemResolver interface {
390 ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (string, error)
391 Author(ctx context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, error)
392
393 CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
394 LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
395}
396type BugResolver interface {
397 ID(ctx context.Context, obj models.BugWrapper) (string, error)
398 HumanID(ctx context.Context, obj models.BugWrapper) (string, error)
399 Status(ctx context.Context, obj models.BugWrapper) (models.Status, error)
400
401 Actors(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
402 Participants(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
403 Comments(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
404 Timeline(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
405 Operations(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
406}
407type ColorResolver interface {
408 R(ctx context.Context, obj *color.RGBA) (int, error)
409 G(ctx context.Context, obj *color.RGBA) (int, error)
410 B(ctx context.Context, obj *color.RGBA) (int, error)
411}
412type CommentResolver interface {
413 Author(ctx context.Context, obj *bug.Comment) (models.IdentityWrapper, error)
414}
415type CommentHistoryStepResolver interface {
416 Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
417}
418type CreateOperationResolver interface {
419 ID(ctx context.Context, obj *bug.CreateOperation) (string, error)
420 Author(ctx context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error)
421 Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
422}
423type CreateTimelineItemResolver interface {
424 ID(ctx context.Context, obj *bug.CreateTimelineItem) (string, error)
425 Author(ctx context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error)
426
427 CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
428 LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
429}
430type EditCommentOperationResolver interface {
431 ID(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
432 Author(ctx context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error)
433 Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
434 Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
435}
436type IdentityResolver interface {
437 ID(ctx context.Context, obj models.IdentityWrapper) (string, error)
438 HumanID(ctx context.Context, obj models.IdentityWrapper) (string, error)
439}
440type LabelResolver interface {
441 Name(ctx context.Context, obj *bug.Label) (string, error)
442 Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
443}
444type LabelChangeOperationResolver interface {
445 ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
446 Author(ctx context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error)
447 Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
448}
449type LabelChangeResultResolver interface {
450 Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
451}
452type LabelChangeTimelineItemResolver interface {
453 ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
454 Author(ctx context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error)
455 Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
456}
457type MutationResolver interface {
458 NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
459 AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
460 AddCommentAndClose(ctx context.Context, input models.AddCommentAndCloseBugInput) (*models.AddCommentAndCloseBugPayload, error)
461 AddCommentAndReopen(ctx context.Context, input models.AddCommentAndReopenBugInput) (*models.AddCommentAndReopenBugPayload, error)
462 EditComment(ctx context.Context, input models.EditCommentInput) (*models.EditCommentPayload, error)
463 ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
464 OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
465 CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
466 SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
467}
468type QueryResolver interface {
469 Repository(ctx context.Context, ref *string) (*models.Repository, error)
470}
471type RepositoryResolver interface {
472 Name(ctx context.Context, obj *models.Repository) (*string, error)
473 AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
474 Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
475 AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
476 Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
477 UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
478 ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
479}
480type SetStatusOperationResolver interface {
481 ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
482 Author(ctx context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error)
483 Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
484 Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
485}
486type SetStatusTimelineItemResolver interface {
487 ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
488 Author(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error)
489 Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
490 Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
491}
492type SetTitleOperationResolver interface {
493 ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
494 Author(ctx context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error)
495 Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
496}
497type SetTitleTimelineItemResolver interface {
498 ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
499 Author(ctx context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error)
500 Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
501}
502
503type executableSchema struct {
504 resolvers ResolverRoot
505 directives DirectiveRoot
506 complexity ComplexityRoot
507}
508
509func (e *executableSchema) Schema() *ast.Schema {
510 return parsedSchema
511}
512
513func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
514 ec := executionContext{nil, e}
515 _ = ec
516 switch typeName + "." + field {
517
518 case "AddCommentAndCloseBugPayload.bug":
519 if e.complexity.AddCommentAndCloseBugPayload.Bug == nil {
520 break
521 }
522
523 return e.complexity.AddCommentAndCloseBugPayload.Bug(childComplexity), true
524
525 case "AddCommentAndCloseBugPayload.clientMutationId":
526 if e.complexity.AddCommentAndCloseBugPayload.ClientMutationID == nil {
527 break
528 }
529
530 return e.complexity.AddCommentAndCloseBugPayload.ClientMutationID(childComplexity), true
531
532 case "AddCommentAndCloseBugPayload.commentOperation":
533 if e.complexity.AddCommentAndCloseBugPayload.CommentOperation == nil {
534 break
535 }
536
537 return e.complexity.AddCommentAndCloseBugPayload.CommentOperation(childComplexity), true
538
539 case "AddCommentAndCloseBugPayload.statusOperation":
540 if e.complexity.AddCommentAndCloseBugPayload.StatusOperation == nil {
541 break
542 }
543
544 return e.complexity.AddCommentAndCloseBugPayload.StatusOperation(childComplexity), true
545
546 case "AddCommentAndReopenBugPayload.bug":
547 if e.complexity.AddCommentAndReopenBugPayload.Bug == nil {
548 break
549 }
550
551 return e.complexity.AddCommentAndReopenBugPayload.Bug(childComplexity), true
552
553 case "AddCommentAndReopenBugPayload.clientMutationId":
554 if e.complexity.AddCommentAndReopenBugPayload.ClientMutationID == nil {
555 break
556 }
557
558 return e.complexity.AddCommentAndReopenBugPayload.ClientMutationID(childComplexity), true
559
560 case "AddCommentAndReopenBugPayload.commentOperation":
561 if e.complexity.AddCommentAndReopenBugPayload.CommentOperation == nil {
562 break
563 }
564
565 return e.complexity.AddCommentAndReopenBugPayload.CommentOperation(childComplexity), true
566
567 case "AddCommentAndReopenBugPayload.statusOperation":
568 if e.complexity.AddCommentAndReopenBugPayload.StatusOperation == nil {
569 break
570 }
571
572 return e.complexity.AddCommentAndReopenBugPayload.StatusOperation(childComplexity), true
573
574 case "AddCommentOperation.author":
575 if e.complexity.AddCommentOperation.Author == nil {
576 break
577 }
578
579 return e.complexity.AddCommentOperation.Author(childComplexity), true
580
581 case "AddCommentOperation.date":
582 if e.complexity.AddCommentOperation.Date == nil {
583 break
584 }
585
586 return e.complexity.AddCommentOperation.Date(childComplexity), true
587
588 case "AddCommentOperation.files":
589 if e.complexity.AddCommentOperation.Files == nil {
590 break
591 }
592
593 return e.complexity.AddCommentOperation.Files(childComplexity), true
594
595 case "AddCommentOperation.id":
596 if e.complexity.AddCommentOperation.ID == nil {
597 break
598 }
599
600 return e.complexity.AddCommentOperation.ID(childComplexity), true
601
602 case "AddCommentOperation.message":
603 if e.complexity.AddCommentOperation.Message == nil {
604 break
605 }
606
607 return e.complexity.AddCommentOperation.Message(childComplexity), true
608
609 case "AddCommentPayload.bug":
610 if e.complexity.AddCommentPayload.Bug == nil {
611 break
612 }
613
614 return e.complexity.AddCommentPayload.Bug(childComplexity), true
615
616 case "AddCommentPayload.clientMutationId":
617 if e.complexity.AddCommentPayload.ClientMutationID == nil {
618 break
619 }
620
621 return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
622
623 case "AddCommentPayload.operation":
624 if e.complexity.AddCommentPayload.Operation == nil {
625 break
626 }
627
628 return e.complexity.AddCommentPayload.Operation(childComplexity), true
629
630 case "AddCommentTimelineItem.author":
631 if e.complexity.AddCommentTimelineItem.Author == nil {
632 break
633 }
634
635 return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
636
637 case "AddCommentTimelineItem.createdAt":
638 if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
639 break
640 }
641
642 return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
643
644 case "AddCommentTimelineItem.edited":
645 if e.complexity.AddCommentTimelineItem.Edited == nil {
646 break
647 }
648
649 return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
650
651 case "AddCommentTimelineItem.files":
652 if e.complexity.AddCommentTimelineItem.Files == nil {
653 break
654 }
655
656 return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
657
658 case "AddCommentTimelineItem.history":
659 if e.complexity.AddCommentTimelineItem.History == nil {
660 break
661 }
662
663 return e.complexity.AddCommentTimelineItem.History(childComplexity), true
664
665 case "AddCommentTimelineItem.id":
666 if e.complexity.AddCommentTimelineItem.ID == nil {
667 break
668 }
669
670 return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
671
672 case "AddCommentTimelineItem.lastEdit":
673 if e.complexity.AddCommentTimelineItem.LastEdit == nil {
674 break
675 }
676
677 return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
678
679 case "AddCommentTimelineItem.message":
680 if e.complexity.AddCommentTimelineItem.Message == nil {
681 break
682 }
683
684 return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
685
686 case "AddCommentTimelineItem.messageIsEmpty":
687 if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
688 break
689 }
690
691 return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
692
693 case "Bug.actors":
694 if e.complexity.Bug.Actors == nil {
695 break
696 }
697
698 args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
699 if err != nil {
700 return 0, false
701 }
702
703 return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
704
705 case "Bug.author":
706 if e.complexity.Bug.Author == nil {
707 break
708 }
709
710 return e.complexity.Bug.Author(childComplexity), true
711
712 case "Bug.comments":
713 if e.complexity.Bug.Comments == nil {
714 break
715 }
716
717 args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
718 if err != nil {
719 return 0, false
720 }
721
722 return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
723
724 case "Bug.createdAt":
725 if e.complexity.Bug.CreatedAt == nil {
726 break
727 }
728
729 return e.complexity.Bug.CreatedAt(childComplexity), true
730
731 case "Bug.humanId":
732 if e.complexity.Bug.HumanID == nil {
733 break
734 }
735
736 return e.complexity.Bug.HumanID(childComplexity), true
737
738 case "Bug.id":
739 if e.complexity.Bug.ID == nil {
740 break
741 }
742
743 return e.complexity.Bug.ID(childComplexity), true
744
745 case "Bug.labels":
746 if e.complexity.Bug.Labels == nil {
747 break
748 }
749
750 return e.complexity.Bug.Labels(childComplexity), true
751
752 case "Bug.lastEdit":
753 if e.complexity.Bug.LastEdit == nil {
754 break
755 }
756
757 return e.complexity.Bug.LastEdit(childComplexity), true
758
759 case "Bug.operations":
760 if e.complexity.Bug.Operations == nil {
761 break
762 }
763
764 args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
765 if err != nil {
766 return 0, false
767 }
768
769 return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
770
771 case "Bug.participants":
772 if e.complexity.Bug.Participants == nil {
773 break
774 }
775
776 args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
777 if err != nil {
778 return 0, false
779 }
780
781 return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
782
783 case "Bug.status":
784 if e.complexity.Bug.Status == nil {
785 break
786 }
787
788 return e.complexity.Bug.Status(childComplexity), true
789
790 case "Bug.timeline":
791 if e.complexity.Bug.Timeline == nil {
792 break
793 }
794
795 args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
796 if err != nil {
797 return 0, false
798 }
799
800 return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
801
802 case "Bug.title":
803 if e.complexity.Bug.Title == nil {
804 break
805 }
806
807 return e.complexity.Bug.Title(childComplexity), true
808
809 case "BugConnection.edges":
810 if e.complexity.BugConnection.Edges == nil {
811 break
812 }
813
814 return e.complexity.BugConnection.Edges(childComplexity), true
815
816 case "BugConnection.nodes":
817 if e.complexity.BugConnection.Nodes == nil {
818 break
819 }
820
821 return e.complexity.BugConnection.Nodes(childComplexity), true
822
823 case "BugConnection.pageInfo":
824 if e.complexity.BugConnection.PageInfo == nil {
825 break
826 }
827
828 return e.complexity.BugConnection.PageInfo(childComplexity), true
829
830 case "BugConnection.totalCount":
831 if e.complexity.BugConnection.TotalCount == nil {
832 break
833 }
834
835 return e.complexity.BugConnection.TotalCount(childComplexity), true
836
837 case "BugEdge.cursor":
838 if e.complexity.BugEdge.Cursor == nil {
839 break
840 }
841
842 return e.complexity.BugEdge.Cursor(childComplexity), true
843
844 case "BugEdge.node":
845 if e.complexity.BugEdge.Node == nil {
846 break
847 }
848
849 return e.complexity.BugEdge.Node(childComplexity), true
850
851 case "ChangeLabelPayload.bug":
852 if e.complexity.ChangeLabelPayload.Bug == nil {
853 break
854 }
855
856 return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
857
858 case "ChangeLabelPayload.clientMutationId":
859 if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
860 break
861 }
862
863 return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
864
865 case "ChangeLabelPayload.operation":
866 if e.complexity.ChangeLabelPayload.Operation == nil {
867 break
868 }
869
870 return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
871
872 case "ChangeLabelPayload.results":
873 if e.complexity.ChangeLabelPayload.Results == nil {
874 break
875 }
876
877 return e.complexity.ChangeLabelPayload.Results(childComplexity), true
878
879 case "CloseBugPayload.bug":
880 if e.complexity.CloseBugPayload.Bug == nil {
881 break
882 }
883
884 return e.complexity.CloseBugPayload.Bug(childComplexity), true
885
886 case "CloseBugPayload.clientMutationId":
887 if e.complexity.CloseBugPayload.ClientMutationID == nil {
888 break
889 }
890
891 return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
892
893 case "CloseBugPayload.operation":
894 if e.complexity.CloseBugPayload.Operation == nil {
895 break
896 }
897
898 return e.complexity.CloseBugPayload.Operation(childComplexity), true
899
900 case "Color.B":
901 if e.complexity.Color.B == nil {
902 break
903 }
904
905 return e.complexity.Color.B(childComplexity), true
906
907 case "Color.G":
908 if e.complexity.Color.G == nil {
909 break
910 }
911
912 return e.complexity.Color.G(childComplexity), true
913
914 case "Color.R":
915 if e.complexity.Color.R == nil {
916 break
917 }
918
919 return e.complexity.Color.R(childComplexity), true
920
921 case "Comment.author":
922 if e.complexity.Comment.Author == nil {
923 break
924 }
925
926 return e.complexity.Comment.Author(childComplexity), true
927
928 case "Comment.files":
929 if e.complexity.Comment.Files == nil {
930 break
931 }
932
933 return e.complexity.Comment.Files(childComplexity), true
934
935 case "Comment.message":
936 if e.complexity.Comment.Message == nil {
937 break
938 }
939
940 return e.complexity.Comment.Message(childComplexity), true
941
942 case "CommentConnection.edges":
943 if e.complexity.CommentConnection.Edges == nil {
944 break
945 }
946
947 return e.complexity.CommentConnection.Edges(childComplexity), true
948
949 case "CommentConnection.nodes":
950 if e.complexity.CommentConnection.Nodes == nil {
951 break
952 }
953
954 return e.complexity.CommentConnection.Nodes(childComplexity), true
955
956 case "CommentConnection.pageInfo":
957 if e.complexity.CommentConnection.PageInfo == nil {
958 break
959 }
960
961 return e.complexity.CommentConnection.PageInfo(childComplexity), true
962
963 case "CommentConnection.totalCount":
964 if e.complexity.CommentConnection.TotalCount == nil {
965 break
966 }
967
968 return e.complexity.CommentConnection.TotalCount(childComplexity), true
969
970 case "CommentEdge.cursor":
971 if e.complexity.CommentEdge.Cursor == nil {
972 break
973 }
974
975 return e.complexity.CommentEdge.Cursor(childComplexity), true
976
977 case "CommentEdge.node":
978 if e.complexity.CommentEdge.Node == nil {
979 break
980 }
981
982 return e.complexity.CommentEdge.Node(childComplexity), true
983
984 case "CommentHistoryStep.date":
985 if e.complexity.CommentHistoryStep.Date == nil {
986 break
987 }
988
989 return e.complexity.CommentHistoryStep.Date(childComplexity), true
990
991 case "CommentHistoryStep.message":
992 if e.complexity.CommentHistoryStep.Message == nil {
993 break
994 }
995
996 return e.complexity.CommentHistoryStep.Message(childComplexity), true
997
998 case "CreateOperation.author":
999 if e.complexity.CreateOperation.Author == nil {
1000 break
1001 }
1002
1003 return e.complexity.CreateOperation.Author(childComplexity), true
1004
1005 case "CreateOperation.date":
1006 if e.complexity.CreateOperation.Date == nil {
1007 break
1008 }
1009
1010 return e.complexity.CreateOperation.Date(childComplexity), true
1011
1012 case "CreateOperation.files":
1013 if e.complexity.CreateOperation.Files == nil {
1014 break
1015 }
1016
1017 return e.complexity.CreateOperation.Files(childComplexity), true
1018
1019 case "CreateOperation.id":
1020 if e.complexity.CreateOperation.ID == nil {
1021 break
1022 }
1023
1024 return e.complexity.CreateOperation.ID(childComplexity), true
1025
1026 case "CreateOperation.message":
1027 if e.complexity.CreateOperation.Message == nil {
1028 break
1029 }
1030
1031 return e.complexity.CreateOperation.Message(childComplexity), true
1032
1033 case "CreateOperation.title":
1034 if e.complexity.CreateOperation.Title == nil {
1035 break
1036 }
1037
1038 return e.complexity.CreateOperation.Title(childComplexity), true
1039
1040 case "CreateTimelineItem.author":
1041 if e.complexity.CreateTimelineItem.Author == nil {
1042 break
1043 }
1044
1045 return e.complexity.CreateTimelineItem.Author(childComplexity), true
1046
1047 case "CreateTimelineItem.createdAt":
1048 if e.complexity.CreateTimelineItem.CreatedAt == nil {
1049 break
1050 }
1051
1052 return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
1053
1054 case "CreateTimelineItem.edited":
1055 if e.complexity.CreateTimelineItem.Edited == nil {
1056 break
1057 }
1058
1059 return e.complexity.CreateTimelineItem.Edited(childComplexity), true
1060
1061 case "CreateTimelineItem.files":
1062 if e.complexity.CreateTimelineItem.Files == nil {
1063 break
1064 }
1065
1066 return e.complexity.CreateTimelineItem.Files(childComplexity), true
1067
1068 case "CreateTimelineItem.history":
1069 if e.complexity.CreateTimelineItem.History == nil {
1070 break
1071 }
1072
1073 return e.complexity.CreateTimelineItem.History(childComplexity), true
1074
1075 case "CreateTimelineItem.id":
1076 if e.complexity.CreateTimelineItem.ID == nil {
1077 break
1078 }
1079
1080 return e.complexity.CreateTimelineItem.ID(childComplexity), true
1081
1082 case "CreateTimelineItem.lastEdit":
1083 if e.complexity.CreateTimelineItem.LastEdit == nil {
1084 break
1085 }
1086
1087 return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
1088
1089 case "CreateTimelineItem.message":
1090 if e.complexity.CreateTimelineItem.Message == nil {
1091 break
1092 }
1093
1094 return e.complexity.CreateTimelineItem.Message(childComplexity), true
1095
1096 case "CreateTimelineItem.messageIsEmpty":
1097 if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
1098 break
1099 }
1100
1101 return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
1102
1103 case "EditCommentOperation.author":
1104 if e.complexity.EditCommentOperation.Author == nil {
1105 break
1106 }
1107
1108 return e.complexity.EditCommentOperation.Author(childComplexity), true
1109
1110 case "EditCommentOperation.date":
1111 if e.complexity.EditCommentOperation.Date == nil {
1112 break
1113 }
1114
1115 return e.complexity.EditCommentOperation.Date(childComplexity), true
1116
1117 case "EditCommentOperation.files":
1118 if e.complexity.EditCommentOperation.Files == nil {
1119 break
1120 }
1121
1122 return e.complexity.EditCommentOperation.Files(childComplexity), true
1123
1124 case "EditCommentOperation.id":
1125 if e.complexity.EditCommentOperation.ID == nil {
1126 break
1127 }
1128
1129 return e.complexity.EditCommentOperation.ID(childComplexity), true
1130
1131 case "EditCommentOperation.message":
1132 if e.complexity.EditCommentOperation.Message == nil {
1133 break
1134 }
1135
1136 return e.complexity.EditCommentOperation.Message(childComplexity), true
1137
1138 case "EditCommentOperation.target":
1139 if e.complexity.EditCommentOperation.Target == nil {
1140 break
1141 }
1142
1143 return e.complexity.EditCommentOperation.Target(childComplexity), true
1144
1145 case "EditCommentPayload.bug":
1146 if e.complexity.EditCommentPayload.Bug == nil {
1147 break
1148 }
1149
1150 return e.complexity.EditCommentPayload.Bug(childComplexity), true
1151
1152 case "EditCommentPayload.clientMutationId":
1153 if e.complexity.EditCommentPayload.ClientMutationID == nil {
1154 break
1155 }
1156
1157 return e.complexity.EditCommentPayload.ClientMutationID(childComplexity), true
1158
1159 case "EditCommentPayload.operation":
1160 if e.complexity.EditCommentPayload.Operation == nil {
1161 break
1162 }
1163
1164 return e.complexity.EditCommentPayload.Operation(childComplexity), true
1165
1166 case "Identity.avatarUrl":
1167 if e.complexity.Identity.AvatarUrl == nil {
1168 break
1169 }
1170
1171 return e.complexity.Identity.AvatarUrl(childComplexity), true
1172
1173 case "Identity.displayName":
1174 if e.complexity.Identity.DisplayName == nil {
1175 break
1176 }
1177
1178 return e.complexity.Identity.DisplayName(childComplexity), true
1179
1180 case "Identity.email":
1181 if e.complexity.Identity.Email == nil {
1182 break
1183 }
1184
1185 return e.complexity.Identity.Email(childComplexity), true
1186
1187 case "Identity.humanId":
1188 if e.complexity.Identity.HumanID == nil {
1189 break
1190 }
1191
1192 return e.complexity.Identity.HumanID(childComplexity), true
1193
1194 case "Identity.id":
1195 if e.complexity.Identity.ID == nil {
1196 break
1197 }
1198
1199 return e.complexity.Identity.ID(childComplexity), true
1200
1201 case "Identity.isProtected":
1202 if e.complexity.Identity.IsProtected == nil {
1203 break
1204 }
1205
1206 return e.complexity.Identity.IsProtected(childComplexity), true
1207
1208 case "Identity.login":
1209 if e.complexity.Identity.Login == nil {
1210 break
1211 }
1212
1213 return e.complexity.Identity.Login(childComplexity), true
1214
1215 case "Identity.name":
1216 if e.complexity.Identity.Name == nil {
1217 break
1218 }
1219
1220 return e.complexity.Identity.Name(childComplexity), true
1221
1222 case "IdentityConnection.edges":
1223 if e.complexity.IdentityConnection.Edges == nil {
1224 break
1225 }
1226
1227 return e.complexity.IdentityConnection.Edges(childComplexity), true
1228
1229 case "IdentityConnection.nodes":
1230 if e.complexity.IdentityConnection.Nodes == nil {
1231 break
1232 }
1233
1234 return e.complexity.IdentityConnection.Nodes(childComplexity), true
1235
1236 case "IdentityConnection.pageInfo":
1237 if e.complexity.IdentityConnection.PageInfo == nil {
1238 break
1239 }
1240
1241 return e.complexity.IdentityConnection.PageInfo(childComplexity), true
1242
1243 case "IdentityConnection.totalCount":
1244 if e.complexity.IdentityConnection.TotalCount == nil {
1245 break
1246 }
1247
1248 return e.complexity.IdentityConnection.TotalCount(childComplexity), true
1249
1250 case "IdentityEdge.cursor":
1251 if e.complexity.IdentityEdge.Cursor == nil {
1252 break
1253 }
1254
1255 return e.complexity.IdentityEdge.Cursor(childComplexity), true
1256
1257 case "IdentityEdge.node":
1258 if e.complexity.IdentityEdge.Node == nil {
1259 break
1260 }
1261
1262 return e.complexity.IdentityEdge.Node(childComplexity), true
1263
1264 case "Label.color":
1265 if e.complexity.Label.Color == nil {
1266 break
1267 }
1268
1269 return e.complexity.Label.Color(childComplexity), true
1270
1271 case "Label.name":
1272 if e.complexity.Label.Name == nil {
1273 break
1274 }
1275
1276 return e.complexity.Label.Name(childComplexity), true
1277
1278 case "LabelChangeOperation.added":
1279 if e.complexity.LabelChangeOperation.Added == nil {
1280 break
1281 }
1282
1283 return e.complexity.LabelChangeOperation.Added(childComplexity), true
1284
1285 case "LabelChangeOperation.author":
1286 if e.complexity.LabelChangeOperation.Author == nil {
1287 break
1288 }
1289
1290 return e.complexity.LabelChangeOperation.Author(childComplexity), true
1291
1292 case "LabelChangeOperation.date":
1293 if e.complexity.LabelChangeOperation.Date == nil {
1294 break
1295 }
1296
1297 return e.complexity.LabelChangeOperation.Date(childComplexity), true
1298
1299 case "LabelChangeOperation.id":
1300 if e.complexity.LabelChangeOperation.ID == nil {
1301 break
1302 }
1303
1304 return e.complexity.LabelChangeOperation.ID(childComplexity), true
1305
1306 case "LabelChangeOperation.removed":
1307 if e.complexity.LabelChangeOperation.Removed == nil {
1308 break
1309 }
1310
1311 return e.complexity.LabelChangeOperation.Removed(childComplexity), true
1312
1313 case "LabelChangeResult.label":
1314 if e.complexity.LabelChangeResult.Label == nil {
1315 break
1316 }
1317
1318 return e.complexity.LabelChangeResult.Label(childComplexity), true
1319
1320 case "LabelChangeResult.status":
1321 if e.complexity.LabelChangeResult.Status == nil {
1322 break
1323 }
1324
1325 return e.complexity.LabelChangeResult.Status(childComplexity), true
1326
1327 case "LabelChangeTimelineItem.added":
1328 if e.complexity.LabelChangeTimelineItem.Added == nil {
1329 break
1330 }
1331
1332 return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
1333
1334 case "LabelChangeTimelineItem.author":
1335 if e.complexity.LabelChangeTimelineItem.Author == nil {
1336 break
1337 }
1338
1339 return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
1340
1341 case "LabelChangeTimelineItem.date":
1342 if e.complexity.LabelChangeTimelineItem.Date == nil {
1343 break
1344 }
1345
1346 return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
1347
1348 case "LabelChangeTimelineItem.id":
1349 if e.complexity.LabelChangeTimelineItem.ID == nil {
1350 break
1351 }
1352
1353 return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
1354
1355 case "LabelChangeTimelineItem.removed":
1356 if e.complexity.LabelChangeTimelineItem.Removed == nil {
1357 break
1358 }
1359
1360 return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
1361
1362 case "LabelConnection.edges":
1363 if e.complexity.LabelConnection.Edges == nil {
1364 break
1365 }
1366
1367 return e.complexity.LabelConnection.Edges(childComplexity), true
1368
1369 case "LabelConnection.nodes":
1370 if e.complexity.LabelConnection.Nodes == nil {
1371 break
1372 }
1373
1374 return e.complexity.LabelConnection.Nodes(childComplexity), true
1375
1376 case "LabelConnection.pageInfo":
1377 if e.complexity.LabelConnection.PageInfo == nil {
1378 break
1379 }
1380
1381 return e.complexity.LabelConnection.PageInfo(childComplexity), true
1382
1383 case "LabelConnection.totalCount":
1384 if e.complexity.LabelConnection.TotalCount == nil {
1385 break
1386 }
1387
1388 return e.complexity.LabelConnection.TotalCount(childComplexity), true
1389
1390 case "LabelEdge.cursor":
1391 if e.complexity.LabelEdge.Cursor == nil {
1392 break
1393 }
1394
1395 return e.complexity.LabelEdge.Cursor(childComplexity), true
1396
1397 case "LabelEdge.node":
1398 if e.complexity.LabelEdge.Node == nil {
1399 break
1400 }
1401
1402 return e.complexity.LabelEdge.Node(childComplexity), true
1403
1404 case "Mutation.addComment":
1405 if e.complexity.Mutation.AddComment == nil {
1406 break
1407 }
1408
1409 args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
1410 if err != nil {
1411 return 0, false
1412 }
1413
1414 return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
1415
1416 case "Mutation.addCommentAndClose":
1417 if e.complexity.Mutation.AddCommentAndClose == nil {
1418 break
1419 }
1420
1421 args, err := ec.field_Mutation_addCommentAndClose_args(context.TODO(), rawArgs)
1422 if err != nil {
1423 return 0, false
1424 }
1425
1426 return e.complexity.Mutation.AddCommentAndClose(childComplexity, args["input"].(models.AddCommentAndCloseBugInput)), true
1427
1428 case "Mutation.addCommentAndReopen":
1429 if e.complexity.Mutation.AddCommentAndReopen == nil {
1430 break
1431 }
1432
1433 args, err := ec.field_Mutation_addCommentAndReopen_args(context.TODO(), rawArgs)
1434 if err != nil {
1435 return 0, false
1436 }
1437
1438 return e.complexity.Mutation.AddCommentAndReopen(childComplexity, args["input"].(models.AddCommentAndReopenBugInput)), true
1439
1440 case "Mutation.changeLabels":
1441 if e.complexity.Mutation.ChangeLabels == nil {
1442 break
1443 }
1444
1445 args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
1446 if err != nil {
1447 return 0, false
1448 }
1449
1450 return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
1451
1452 case "Mutation.closeBug":
1453 if e.complexity.Mutation.CloseBug == nil {
1454 break
1455 }
1456
1457 args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
1458 if err != nil {
1459 return 0, false
1460 }
1461
1462 return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
1463
1464 case "Mutation.editComment":
1465 if e.complexity.Mutation.EditComment == nil {
1466 break
1467 }
1468
1469 args, err := ec.field_Mutation_editComment_args(context.TODO(), rawArgs)
1470 if err != nil {
1471 return 0, false
1472 }
1473
1474 return e.complexity.Mutation.EditComment(childComplexity, args["input"].(models.EditCommentInput)), true
1475
1476 case "Mutation.newBug":
1477 if e.complexity.Mutation.NewBug == nil {
1478 break
1479 }
1480
1481 args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
1482 if err != nil {
1483 return 0, false
1484 }
1485
1486 return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
1487
1488 case "Mutation.openBug":
1489 if e.complexity.Mutation.OpenBug == nil {
1490 break
1491 }
1492
1493 args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
1494 if err != nil {
1495 return 0, false
1496 }
1497
1498 return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
1499
1500 case "Mutation.setTitle":
1501 if e.complexity.Mutation.SetTitle == nil {
1502 break
1503 }
1504
1505 args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
1506 if err != nil {
1507 return 0, false
1508 }
1509
1510 return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
1511
1512 case "NewBugPayload.bug":
1513 if e.complexity.NewBugPayload.Bug == nil {
1514 break
1515 }
1516
1517 return e.complexity.NewBugPayload.Bug(childComplexity), true
1518
1519 case "NewBugPayload.clientMutationId":
1520 if e.complexity.NewBugPayload.ClientMutationID == nil {
1521 break
1522 }
1523
1524 return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
1525
1526 case "NewBugPayload.operation":
1527 if e.complexity.NewBugPayload.Operation == nil {
1528 break
1529 }
1530
1531 return e.complexity.NewBugPayload.Operation(childComplexity), true
1532
1533 case "OpenBugPayload.bug":
1534 if e.complexity.OpenBugPayload.Bug == nil {
1535 break
1536 }
1537
1538 return e.complexity.OpenBugPayload.Bug(childComplexity), true
1539
1540 case "OpenBugPayload.clientMutationId":
1541 if e.complexity.OpenBugPayload.ClientMutationID == nil {
1542 break
1543 }
1544
1545 return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
1546
1547 case "OpenBugPayload.operation":
1548 if e.complexity.OpenBugPayload.Operation == nil {
1549 break
1550 }
1551
1552 return e.complexity.OpenBugPayload.Operation(childComplexity), true
1553
1554 case "OperationConnection.edges":
1555 if e.complexity.OperationConnection.Edges == nil {
1556 break
1557 }
1558
1559 return e.complexity.OperationConnection.Edges(childComplexity), true
1560
1561 case "OperationConnection.nodes":
1562 if e.complexity.OperationConnection.Nodes == nil {
1563 break
1564 }
1565
1566 return e.complexity.OperationConnection.Nodes(childComplexity), true
1567
1568 case "OperationConnection.pageInfo":
1569 if e.complexity.OperationConnection.PageInfo == nil {
1570 break
1571 }
1572
1573 return e.complexity.OperationConnection.PageInfo(childComplexity), true
1574
1575 case "OperationConnection.totalCount":
1576 if e.complexity.OperationConnection.TotalCount == nil {
1577 break
1578 }
1579
1580 return e.complexity.OperationConnection.TotalCount(childComplexity), true
1581
1582 case "OperationEdge.cursor":
1583 if e.complexity.OperationEdge.Cursor == nil {
1584 break
1585 }
1586
1587 return e.complexity.OperationEdge.Cursor(childComplexity), true
1588
1589 case "OperationEdge.node":
1590 if e.complexity.OperationEdge.Node == nil {
1591 break
1592 }
1593
1594 return e.complexity.OperationEdge.Node(childComplexity), true
1595
1596 case "PageInfo.endCursor":
1597 if e.complexity.PageInfo.EndCursor == nil {
1598 break
1599 }
1600
1601 return e.complexity.PageInfo.EndCursor(childComplexity), true
1602
1603 case "PageInfo.hasNextPage":
1604 if e.complexity.PageInfo.HasNextPage == nil {
1605 break
1606 }
1607
1608 return e.complexity.PageInfo.HasNextPage(childComplexity), true
1609
1610 case "PageInfo.hasPreviousPage":
1611 if e.complexity.PageInfo.HasPreviousPage == nil {
1612 break
1613 }
1614
1615 return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
1616
1617 case "PageInfo.startCursor":
1618 if e.complexity.PageInfo.StartCursor == nil {
1619 break
1620 }
1621
1622 return e.complexity.PageInfo.StartCursor(childComplexity), true
1623
1624 case "Query.repository":
1625 if e.complexity.Query.Repository == nil {
1626 break
1627 }
1628
1629 args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
1630 if err != nil {
1631 return 0, false
1632 }
1633
1634 return e.complexity.Query.Repository(childComplexity, args["ref"].(*string)), true
1635
1636 case "Repository.allBugs":
1637 if e.complexity.Repository.AllBugs == nil {
1638 break
1639 }
1640
1641 args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
1642 if err != nil {
1643 return 0, false
1644 }
1645
1646 return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
1647
1648 case "Repository.allIdentities":
1649 if e.complexity.Repository.AllIdentities == nil {
1650 break
1651 }
1652
1653 args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
1654 if err != nil {
1655 return 0, false
1656 }
1657
1658 return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1659
1660 case "Repository.bug":
1661 if e.complexity.Repository.Bug == nil {
1662 break
1663 }
1664
1665 args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
1666 if err != nil {
1667 return 0, false
1668 }
1669
1670 return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
1671
1672 case "Repository.identity":
1673 if e.complexity.Repository.Identity == nil {
1674 break
1675 }
1676
1677 args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
1678 if err != nil {
1679 return 0, false
1680 }
1681
1682 return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
1683
1684 case "Repository.name":
1685 if e.complexity.Repository.Name == nil {
1686 break
1687 }
1688
1689 return e.complexity.Repository.Name(childComplexity), true
1690
1691 case "Repository.userIdentity":
1692 if e.complexity.Repository.UserIdentity == nil {
1693 break
1694 }
1695
1696 return e.complexity.Repository.UserIdentity(childComplexity), true
1697
1698 case "Repository.validLabels":
1699 if e.complexity.Repository.ValidLabels == nil {
1700 break
1701 }
1702
1703 args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
1704 if err != nil {
1705 return 0, false
1706 }
1707
1708 return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1709
1710 case "SetStatusOperation.author":
1711 if e.complexity.SetStatusOperation.Author == nil {
1712 break
1713 }
1714
1715 return e.complexity.SetStatusOperation.Author(childComplexity), true
1716
1717 case "SetStatusOperation.date":
1718 if e.complexity.SetStatusOperation.Date == nil {
1719 break
1720 }
1721
1722 return e.complexity.SetStatusOperation.Date(childComplexity), true
1723
1724 case "SetStatusOperation.id":
1725 if e.complexity.SetStatusOperation.ID == nil {
1726 break
1727 }
1728
1729 return e.complexity.SetStatusOperation.ID(childComplexity), true
1730
1731 case "SetStatusOperation.status":
1732 if e.complexity.SetStatusOperation.Status == nil {
1733 break
1734 }
1735
1736 return e.complexity.SetStatusOperation.Status(childComplexity), true
1737
1738 case "SetStatusTimelineItem.author":
1739 if e.complexity.SetStatusTimelineItem.Author == nil {
1740 break
1741 }
1742
1743 return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
1744
1745 case "SetStatusTimelineItem.date":
1746 if e.complexity.SetStatusTimelineItem.Date == nil {
1747 break
1748 }
1749
1750 return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
1751
1752 case "SetStatusTimelineItem.id":
1753 if e.complexity.SetStatusTimelineItem.ID == nil {
1754 break
1755 }
1756
1757 return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
1758
1759 case "SetStatusTimelineItem.status":
1760 if e.complexity.SetStatusTimelineItem.Status == nil {
1761 break
1762 }
1763
1764 return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
1765
1766 case "SetTitleOperation.author":
1767 if e.complexity.SetTitleOperation.Author == nil {
1768 break
1769 }
1770
1771 return e.complexity.SetTitleOperation.Author(childComplexity), true
1772
1773 case "SetTitleOperation.date":
1774 if e.complexity.SetTitleOperation.Date == nil {
1775 break
1776 }
1777
1778 return e.complexity.SetTitleOperation.Date(childComplexity), true
1779
1780 case "SetTitleOperation.id":
1781 if e.complexity.SetTitleOperation.ID == nil {
1782 break
1783 }
1784
1785 return e.complexity.SetTitleOperation.ID(childComplexity), true
1786
1787 case "SetTitleOperation.title":
1788 if e.complexity.SetTitleOperation.Title == nil {
1789 break
1790 }
1791
1792 return e.complexity.SetTitleOperation.Title(childComplexity), true
1793
1794 case "SetTitleOperation.was":
1795 if e.complexity.SetTitleOperation.Was == nil {
1796 break
1797 }
1798
1799 return e.complexity.SetTitleOperation.Was(childComplexity), true
1800
1801 case "SetTitlePayload.bug":
1802 if e.complexity.SetTitlePayload.Bug == nil {
1803 break
1804 }
1805
1806 return e.complexity.SetTitlePayload.Bug(childComplexity), true
1807
1808 case "SetTitlePayload.clientMutationId":
1809 if e.complexity.SetTitlePayload.ClientMutationID == nil {
1810 break
1811 }
1812
1813 return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
1814
1815 case "SetTitlePayload.operation":
1816 if e.complexity.SetTitlePayload.Operation == nil {
1817 break
1818 }
1819
1820 return e.complexity.SetTitlePayload.Operation(childComplexity), true
1821
1822 case "SetTitleTimelineItem.author":
1823 if e.complexity.SetTitleTimelineItem.Author == nil {
1824 break
1825 }
1826
1827 return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
1828
1829 case "SetTitleTimelineItem.date":
1830 if e.complexity.SetTitleTimelineItem.Date == nil {
1831 break
1832 }
1833
1834 return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
1835
1836 case "SetTitleTimelineItem.id":
1837 if e.complexity.SetTitleTimelineItem.ID == nil {
1838 break
1839 }
1840
1841 return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
1842
1843 case "SetTitleTimelineItem.title":
1844 if e.complexity.SetTitleTimelineItem.Title == nil {
1845 break
1846 }
1847
1848 return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
1849
1850 case "SetTitleTimelineItem.was":
1851 if e.complexity.SetTitleTimelineItem.Was == nil {
1852 break
1853 }
1854
1855 return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
1856
1857 case "TimelineItemConnection.edges":
1858 if e.complexity.TimelineItemConnection.Edges == nil {
1859 break
1860 }
1861
1862 return e.complexity.TimelineItemConnection.Edges(childComplexity), true
1863
1864 case "TimelineItemConnection.nodes":
1865 if e.complexity.TimelineItemConnection.Nodes == nil {
1866 break
1867 }
1868
1869 return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
1870
1871 case "TimelineItemConnection.pageInfo":
1872 if e.complexity.TimelineItemConnection.PageInfo == nil {
1873 break
1874 }
1875
1876 return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
1877
1878 case "TimelineItemConnection.totalCount":
1879 if e.complexity.TimelineItemConnection.TotalCount == nil {
1880 break
1881 }
1882
1883 return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
1884
1885 case "TimelineItemEdge.cursor":
1886 if e.complexity.TimelineItemEdge.Cursor == nil {
1887 break
1888 }
1889
1890 return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
1891
1892 case "TimelineItemEdge.node":
1893 if e.complexity.TimelineItemEdge.Node == nil {
1894 break
1895 }
1896
1897 return e.complexity.TimelineItemEdge.Node(childComplexity), true
1898
1899 }
1900 return 0, false
1901}
1902
1903func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
1904 rc := graphql.GetOperationContext(ctx)
1905 ec := executionContext{rc, e}
1906 inputUnmarshalMap := graphql.BuildUnmarshalerMap(
1907 ec.unmarshalInputAddCommentAndCloseBugInput,
1908 ec.unmarshalInputAddCommentAndReopenBugInput,
1909 ec.unmarshalInputAddCommentInput,
1910 ec.unmarshalInputChangeLabelInput,
1911 ec.unmarshalInputCloseBugInput,
1912 ec.unmarshalInputEditCommentInput,
1913 ec.unmarshalInputNewBugInput,
1914 ec.unmarshalInputOpenBugInput,
1915 ec.unmarshalInputSetTitleInput,
1916 )
1917 first := true
1918
1919 switch rc.Operation.Operation {
1920 case ast.Query:
1921 return func(ctx context.Context) *graphql.Response {
1922 if !first {
1923 return nil
1924 }
1925 first = false
1926 ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
1927 data := ec._Query(ctx, rc.Operation.SelectionSet)
1928 var buf bytes.Buffer
1929 data.MarshalGQL(&buf)
1930
1931 return &graphql.Response{
1932 Data: buf.Bytes(),
1933 }
1934 }
1935 case ast.Mutation:
1936 return func(ctx context.Context) *graphql.Response {
1937 if !first {
1938 return nil
1939 }
1940 first = false
1941 ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
1942 data := ec._Mutation(ctx, rc.Operation.SelectionSet)
1943 var buf bytes.Buffer
1944 data.MarshalGQL(&buf)
1945
1946 return &graphql.Response{
1947 Data: buf.Bytes(),
1948 }
1949 }
1950
1951 default:
1952 return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
1953 }
1954}
1955
1956type executionContext struct {
1957 *graphql.OperationContext
1958 *executableSchema
1959}
1960
1961func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
1962 if ec.DisableIntrospection {
1963 return nil, errors.New("introspection disabled")
1964 }
1965 return introspection.WrapSchema(parsedSchema), nil
1966}
1967
1968func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
1969 if ec.DisableIntrospection {
1970 return nil, errors.New("introspection disabled")
1971 }
1972 return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
1973}
1974
1975var sources = []*ast.Source{
1976 {Name: "../schema/bug.graphql", Input: `"""Represents a comment on a bug."""
1977type Comment implements Authored {
1978 """The author of this comment."""
1979 author: Identity!
1980
1981 """The message of this comment."""
1982 message: String!
1983
1984 """All media's hash referenced in this comment"""
1985 files: [Hash!]!
1986}
1987
1988type CommentConnection {
1989 edges: [CommentEdge!]!
1990 nodes: [Comment!]!
1991 pageInfo: PageInfo!
1992 totalCount: Int!
1993}
1994
1995type CommentEdge {
1996 cursor: String!
1997 node: Comment!
1998}
1999
2000enum Status {
2001 OPEN
2002 CLOSED
2003}
2004
2005type Bug implements Authored {
2006 """The identifier for this bug"""
2007 id: String!
2008 """The human version (truncated) identifier for this bug"""
2009 humanId: String!
2010 status: Status!
2011 title: String!
2012 labels: [Label!]!
2013 author: Identity!
2014 createdAt: Time!
2015 lastEdit: Time!
2016
2017 """The actors of the bug. Actors are Identity that have interacted with the bug."""
2018 actors(
2019 """Returns the elements in the list that come after the specified cursor."""
2020 after: String
2021 """Returns the elements in the list that come before the specified cursor."""
2022 before: String
2023 """Returns the first _n_ elements from the list."""
2024 first: Int
2025 """Returns the last _n_ elements from the list."""
2026 last: Int
2027 ): IdentityConnection!
2028
2029 """The participants of the bug. Participants are Identity that have created or
2030 added a comment on the bug."""
2031 participants(
2032 """Returns the elements in the list that come after the specified cursor."""
2033 after: String
2034 """Returns the elements in the list that come before the specified cursor."""
2035 before: String
2036 """Returns the first _n_ elements from the list."""
2037 first: Int
2038 """Returns the last _n_ elements from the list."""
2039 last: Int
2040 ): IdentityConnection!
2041
2042 comments(
2043 """Returns the elements in the list that come after the specified cursor."""
2044 after: String
2045 """Returns the elements in the list that come before the specified cursor."""
2046 before: String
2047 """Returns the first _n_ elements from the list."""
2048 first: Int
2049 """Returns the last _n_ elements from the list."""
2050 last: Int
2051 ): CommentConnection!
2052
2053 timeline(
2054 """Returns the elements in the list that come after the specified cursor."""
2055 after: String
2056 """Returns the elements in the list that come before the specified cursor."""
2057 before: String
2058 """Returns the first _n_ elements from the list."""
2059 first: Int
2060 """Returns the last _n_ elements from the list."""
2061 last: Int
2062 ): TimelineItemConnection!
2063
2064 operations(
2065 """Returns the elements in the list that come after the specified cursor."""
2066 after: String
2067 """Returns the elements in the list that come before the specified cursor."""
2068 before: String
2069 """Returns the first _n_ elements from the list."""
2070 first: Int
2071 """Returns the last _n_ elements from the list."""
2072 last: Int
2073 ): OperationConnection!
2074}
2075
2076"""The connection type for Bug."""
2077type BugConnection {
2078 """A list of edges."""
2079 edges: [BugEdge!]!
2080 nodes: [Bug!]!
2081 """Information to aid in pagination."""
2082 pageInfo: PageInfo!
2083 """Identifies the total count of items in the connection."""
2084 totalCount: Int!
2085}
2086
2087"""An edge in a connection."""
2088type BugEdge {
2089 """A cursor for use in pagination."""
2090 cursor: String!
2091 """The item at the end of the edge."""
2092 node: Bug!
2093}
2094`, BuiltIn: false},
2095 {Name: "../schema/identity.graphql", Input: `"""Represents an identity"""
2096type Identity {
2097 """The identifier for this identity"""
2098 id: String!
2099 """The human version (truncated) identifier for this identity"""
2100 humanId: String!
2101 """The name of the person, if known."""
2102 name: String
2103 """The email of the person, if known."""
2104 email: String
2105 """The login of the person, if known."""
2106 login: String
2107 """A non-empty string to display, representing the identity, based on the non-empty values."""
2108 displayName: String!
2109 """An url to an avatar"""
2110 avatarUrl: String
2111 """isProtected is true if the chain of git commits started to be signed.
2112 If that's the case, only signed commit with a valid key for this identity can be added."""
2113 isProtected: Boolean!
2114}
2115
2116type IdentityConnection {
2117 edges: [IdentityEdge!]!
2118 nodes: [Identity!]!
2119 pageInfo: PageInfo!
2120 totalCount: Int!
2121}
2122
2123type IdentityEdge {
2124 cursor: String!
2125 node: Identity!
2126}`, BuiltIn: false},
2127 {Name: "../schema/label.graphql", Input: `"""Label for a bug."""
2128type Label {
2129 """The name of the label."""
2130 name: String!
2131 """Color of the label."""
2132 color: Color!
2133}
2134
2135type LabelConnection {
2136 edges: [LabelEdge!]!
2137 nodes: [Label!]!
2138 pageInfo: PageInfo!
2139 totalCount: Int!
2140}
2141
2142type LabelEdge {
2143 cursor: String!
2144 node: Label!
2145}`, BuiltIn: false},
2146 {Name: "../schema/mutations.graphql", Input: `input NewBugInput {
2147 """A unique identifier for the client performing the mutation."""
2148 clientMutationId: String
2149 """The name of the repository. If not set, the default repository is used."""
2150 repoRef: String
2151 """The title of the new bug."""
2152 title: String!
2153 """The first message of the new bug."""
2154 message: String!
2155 """The collection of file's hash required for the first message."""
2156 files: [Hash!]
2157}
2158
2159type NewBugPayload {
2160 """A unique identifier for the client performing the mutation."""
2161 clientMutationId: String
2162 """The created bug."""
2163 bug: Bug!
2164 """The resulting operation."""
2165 operation: CreateOperation!
2166}
2167
2168input AddCommentInput {
2169 """A unique identifier for the client performing the mutation."""
2170 clientMutationId: String
2171 """The name of the repository. If not set, the default repository is used."""
2172 repoRef: String
2173 """The bug ID's prefix."""
2174 prefix: String!
2175 """The message to be added to the bug."""
2176 message: String!
2177 """The collection of file's hash required for the first message."""
2178 files: [Hash!]
2179}
2180
2181type AddCommentPayload {
2182 """A unique identifier for the client performing the mutation."""
2183 clientMutationId: String
2184 """The affected bug."""
2185 bug: Bug!
2186 """The resulting operation."""
2187 operation: AddCommentOperation!
2188}
2189
2190input AddCommentAndCloseBugInput {
2191 """A unique identifier for the client performing the mutation."""
2192 clientMutationId: String
2193 """The name of the repository. If not set, the default repository is used."""
2194 repoRef: String
2195 """The bug ID's prefix."""
2196 prefix: String!
2197 """The message to be added to the bug."""
2198 message: String!
2199 """The collection of file's hash required for the first message."""
2200 files: [Hash!]
2201}
2202
2203type AddCommentAndCloseBugPayload {
2204 """A unique identifier for the client performing the mutation."""
2205 clientMutationId: String
2206 """The affected bug."""
2207 bug: Bug!
2208 """The resulting AddComment operation."""
2209 commentOperation: AddCommentOperation!
2210 """The resulting SetStatusOperation."""
2211 statusOperation: SetStatusOperation!
2212}
2213
2214input AddCommentAndReopenBugInput {
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 """The message to be added to the bug."""
2222 message: String!
2223 """The collection of file's hash required for the first message."""
2224 files: [Hash!]
2225}
2226
2227type AddCommentAndReopenBugPayload {
2228 """A unique identifier for the client performing the mutation."""
2229 clientMutationId: String
2230 """The affected bug."""
2231 bug: Bug!
2232 """The resulting AddComment operation."""
2233 commentOperation: AddCommentOperation!
2234 """The resulting SetStatusOperation."""
2235 statusOperation: SetStatusOperation!
2236}
2237
2238input EditCommentInput {
2239 """A unique identifier for the client performing the mutation."""
2240 clientMutationId: String
2241 """The name of the repository. If not set, the default repository is used."""
2242 repoRef: String
2243 """The bug ID's prefix."""
2244 prefix: String!
2245 """The ID of the comment to be changed."""
2246 target: String!
2247 """The new message to be set."""
2248 message: String!
2249 """The collection of file's hash required for the first message."""
2250 files: [Hash!]
2251}
2252
2253type EditCommentPayload {
2254 """A unique identifier for the client performing the mutation."""
2255 clientMutationId: String
2256 """The affected bug."""
2257 bug: Bug!
2258 """The resulting operation."""
2259 operation: EditCommentOperation!
2260}
2261
2262input ChangeLabelInput {
2263 """A unique identifier for the client performing the mutation."""
2264 clientMutationId: String
2265 """The name of the repository. If not set, the default repository is used."""
2266 repoRef: String
2267 """The bug ID's prefix."""
2268 prefix: String!
2269 """The list of label to add."""
2270 added: [String!]
2271 """The list of label to remove."""
2272 Removed: [String!]
2273}
2274
2275enum LabelChangeStatus {
2276 ADDED
2277 REMOVED
2278 DUPLICATE_IN_OP
2279 ALREADY_EXIST
2280 DOESNT_EXIST
2281}
2282
2283type LabelChangeResult {
2284 """The source label."""
2285 label: Label!
2286 """The effect this label had."""
2287 status: LabelChangeStatus!
2288}
2289
2290type ChangeLabelPayload {
2291 """A unique identifier for the client performing the mutation."""
2292 clientMutationId: String
2293 """The affected bug."""
2294 bug: Bug!
2295 """The resulting operation."""
2296 operation: LabelChangeOperation!
2297 """The effect each source label had."""
2298 results: [LabelChangeResult]!
2299}
2300
2301input OpenBugInput {
2302 """A unique identifier for the client performing the mutation."""
2303 clientMutationId: String
2304 """The name of the repository. If not set, the default repository is used."""
2305 repoRef: String
2306 """The bug ID's prefix."""
2307 prefix: String!
2308}
2309
2310type OpenBugPayload {
2311 """A unique identifier for the client performing the mutation."""
2312 clientMutationId: String
2313 """The affected bug."""
2314 bug: Bug!
2315 """The resulting operation."""
2316 operation: SetStatusOperation!
2317}
2318
2319input CloseBugInput {
2320 """A unique identifier for the client performing the mutation."""
2321 clientMutationId: String
2322 """The name of the repository. If not set, the default repository is used."""
2323 repoRef: String
2324 """The bug ID's prefix."""
2325 prefix: String!
2326}
2327
2328type CloseBugPayload {
2329 """A unique identifier for the client performing the mutation."""
2330 clientMutationId: String
2331 """The affected bug."""
2332 bug: Bug!
2333 """The resulting operation."""
2334 operation: SetStatusOperation!
2335}
2336
2337input SetTitleInput {
2338 """A unique identifier for the client performing the mutation."""
2339 clientMutationId: String
2340 """The name of the repository. If not set, the default repository is used."""
2341 repoRef: String
2342 """The bug ID's prefix."""
2343 prefix: String!
2344 """The new title."""
2345 title: String!
2346}
2347
2348type SetTitlePayload {
2349 """A unique identifier for the client performing the mutation."""
2350 clientMutationId: String
2351 """The affected bug."""
2352 bug: Bug!
2353 """The resulting operation"""
2354 operation: SetTitleOperation!
2355}
2356`, BuiltIn: false},
2357 {Name: "../schema/operations.graphql", Input: `"""An operation applied to a bug."""
2358interface Operation {
2359 """The identifier of the operation"""
2360 id: String!
2361 """The operations author."""
2362 author: Identity!
2363 """The datetime when this operation was issued."""
2364 date: Time!
2365}
2366
2367# Connection
2368
2369"""The connection type for an Operation"""
2370type OperationConnection {
2371 edges: [OperationEdge!]!
2372 nodes: [Operation!]!
2373 pageInfo: PageInfo!
2374 totalCount: Int!
2375}
2376
2377"""Represent an Operation"""
2378type OperationEdge {
2379 cursor: String!
2380 node: Operation!
2381}
2382
2383# Operations
2384
2385type CreateOperation implements Operation & Authored {
2386 """The identifier of the operation"""
2387 id: String!
2388 """The author of this object."""
2389 author: Identity!
2390 """The datetime when this operation was issued."""
2391 date: Time!
2392
2393 title: String!
2394 message: String!
2395 files: [Hash!]!
2396}
2397
2398type SetTitleOperation implements Operation & Authored {
2399 """The identifier of the operation"""
2400 id: String!
2401 """The author of this object."""
2402 author: Identity!
2403 """The datetime when this operation was issued."""
2404 date: Time!
2405
2406 title: String!
2407 was: String!
2408}
2409
2410type AddCommentOperation implements Operation & Authored {
2411 """The identifier of the operation"""
2412 id: String!
2413 """The author of this object."""
2414 author: Identity!
2415 """The datetime when this operation was issued."""
2416 date: Time!
2417
2418 message: String!
2419 files: [Hash!]!
2420}
2421
2422type EditCommentOperation implements Operation & Authored {
2423 """The identifier of the operation"""
2424 id: String!
2425 """The author of this object."""
2426 author: Identity!
2427 """The datetime when this operation was issued."""
2428 date: Time!
2429
2430 target: String!
2431 message: String!
2432 files: [Hash!]!
2433}
2434
2435type SetStatusOperation implements Operation & Authored {
2436 """The identifier of the operation"""
2437 id: String!
2438 """The author of this object."""
2439 author: Identity!
2440 """The datetime when this operation was issued."""
2441 date: Time!
2442
2443 status: Status!
2444}
2445
2446type LabelChangeOperation implements Operation & Authored {
2447 """The identifier of the operation"""
2448 id: String!
2449 """The author of this object."""
2450 author: Identity!
2451 """The datetime when this operation was issued."""
2452 date: Time!
2453
2454 added: [Label!]!
2455 removed: [Label!]!
2456}
2457`, BuiltIn: false},
2458 {Name: "../schema/repository.graphql", Input: `
2459type Repository {
2460 """The name of the repository"""
2461 name: String
2462
2463 """All the bugs"""
2464 allBugs(
2465 """Returns the elements in the list that come after the specified cursor."""
2466 after: String
2467 """Returns the elements in the list that come before the specified cursor."""
2468 before: String
2469 """Returns the first _n_ elements from the list."""
2470 first: Int
2471 """Returns the last _n_ elements from the list."""
2472 last: Int
2473 """A query to select and order bugs."""
2474 query: String
2475 ): BugConnection!
2476
2477 bug(prefix: String!): Bug
2478
2479 """All the identities"""
2480 allIdentities(
2481 """Returns the elements in the list that come after the specified cursor."""
2482 after: String
2483 """Returns the elements in the list that come before the specified cursor."""
2484 before: String
2485 """Returns the first _n_ elements from the list."""
2486 first: Int
2487 """Returns the last _n_ elements from the list."""
2488 last: Int
2489 ): IdentityConnection!
2490
2491 identity(prefix: String!): Identity
2492
2493 """The identity created or selected by the user as its own"""
2494 userIdentity: Identity
2495
2496 """List of valid labels."""
2497 validLabels(
2498 """Returns the elements in the list that come after the specified cursor."""
2499 after: String
2500 """Returns the elements in the list that come before the specified cursor."""
2501 before: String
2502 """Returns the first _n_ elements from the list."""
2503 first: Int
2504 """Returns the last _n_ elements from the list."""
2505 last: Int
2506 ): LabelConnection!
2507}
2508`, BuiltIn: false},
2509 {Name: "../schema/root.graphql", Input: `type Query {
2510 """Access a repository by reference/name. If no ref is given, the default repository is returned if any."""
2511 repository(ref: String): Repository
2512}
2513
2514type Mutation {
2515 """Create a new bug"""
2516 newBug(input: NewBugInput!): NewBugPayload!
2517 """Add a new comment to a bug"""
2518 addComment(input: AddCommentInput!): AddCommentPayload!
2519 """Add a new comment to a bug and close it"""
2520 addCommentAndClose(input: AddCommentAndCloseBugInput!): AddCommentAndCloseBugPayload!
2521 """Add a new comment to a bug and reopen it"""
2522 addCommentAndReopen(input: AddCommentAndReopenBugInput!): AddCommentAndReopenBugPayload!
2523 """Change a comment of a bug"""
2524 editComment(input: EditCommentInput!): EditCommentPayload!
2525 """Add or remove a set of label on a bug"""
2526 changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
2527 """Change a bug's status to open"""
2528 openBug(input: OpenBugInput!): OpenBugPayload!
2529 """Change a bug's status to closed"""
2530 closeBug(input: CloseBugInput!): CloseBugPayload!
2531 """Change a bug's title"""
2532 setTitle(input: SetTitleInput!): SetTitlePayload!
2533}
2534`, BuiltIn: false},
2535 {Name: "../schema/timeline.graphql", Input: `"""An item in the timeline of events"""
2536interface TimelineItem {
2537 """The identifier of the source operation"""
2538 id: String!
2539}
2540
2541"""CommentHistoryStep hold one version of a message in the history"""
2542type CommentHistoryStep {
2543 message: String!
2544 date: Time!
2545}
2546
2547# Connection
2548
2549"""The connection type for TimelineItem"""
2550type TimelineItemConnection {
2551 edges: [TimelineItemEdge!]!
2552 nodes: [TimelineItem!]!
2553 pageInfo: PageInfo!
2554 totalCount: Int!
2555}
2556
2557"""Represent a TimelineItem"""
2558type TimelineItemEdge {
2559 cursor: String!
2560 node: TimelineItem!
2561}
2562
2563# Items
2564
2565"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
2566type CreateTimelineItem implements TimelineItem & Authored {
2567 """The identifier of the source operation"""
2568 id: String!
2569 author: Identity!
2570 message: String!
2571 messageIsEmpty: Boolean!
2572 files: [Hash!]!
2573 createdAt: Time!
2574 lastEdit: Time!
2575 edited: Boolean!
2576 history: [CommentHistoryStep!]!
2577}
2578
2579"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
2580type AddCommentTimelineItem implements TimelineItem & Authored {
2581 """The identifier of the source operation"""
2582 id: String!
2583 author: Identity!
2584 message: String!
2585 messageIsEmpty: Boolean!
2586 files: [Hash!]!
2587 createdAt: Time!
2588 lastEdit: Time!
2589 edited: Boolean!
2590 history: [CommentHistoryStep!]!
2591}
2592
2593"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
2594type LabelChangeTimelineItem implements TimelineItem & Authored {
2595 """The identifier of the source operation"""
2596 id: String!
2597 author: Identity!
2598 date: Time!
2599 added: [Label!]!
2600 removed: [Label!]!
2601}
2602
2603"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
2604type SetStatusTimelineItem implements TimelineItem & Authored {
2605 """The identifier of the source operation"""
2606 id: String!
2607 author: Identity!
2608 date: Time!
2609 status: Status!
2610}
2611
2612"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
2613type SetTitleTimelineItem implements TimelineItem & Authored {
2614 """The identifier of the source operation"""
2615 id: String!
2616 author: Identity!
2617 date: Time!
2618 title: String!
2619 was: String!
2620}
2621`, BuiltIn: false},
2622 {Name: "../schema/types.graphql", Input: `scalar Time
2623scalar Hash
2624
2625"""Defines a color by red, green and blue components."""
2626type Color {
2627 """Red component of the color."""
2628 R: Int!
2629 """Green component of the color."""
2630 G: Int!
2631 """Blue component of the color."""
2632 B: Int!
2633}
2634
2635"""Information about pagination in a connection."""
2636type PageInfo {
2637 """When paginating forwards, are there more items?"""
2638 hasNextPage: Boolean!
2639 """When paginating backwards, are there more items?"""
2640 hasPreviousPage: Boolean!
2641 """When paginating backwards, the cursor to continue."""
2642 startCursor: String!
2643 """When paginating forwards, the cursor to continue."""
2644 endCursor: String!
2645}
2646
2647"""An object that has an author."""
2648interface Authored {
2649 """The author of this object."""
2650 author: Identity!
2651}
2652`, BuiltIn: false},
2653}
2654var parsedSchema = gqlparser.MustLoadSchema(sources...)
2655
2656// endregion ************************** generated!.gotpl **************************
2657
2658// region ***************************** args.gotpl *****************************
2659
2660func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2661 var err error
2662 args := map[string]interface{}{}
2663 var arg0 *string
2664 if tmp, ok := rawArgs["after"]; ok {
2665 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
2666 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2667 if err != nil {
2668 return nil, err
2669 }
2670 }
2671 args["after"] = arg0
2672 var arg1 *string
2673 if tmp, ok := rawArgs["before"]; ok {
2674 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
2675 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2676 if err != nil {
2677 return nil, err
2678 }
2679 }
2680 args["before"] = arg1
2681 var arg2 *int
2682 if tmp, ok := rawArgs["first"]; ok {
2683 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
2684 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2685 if err != nil {
2686 return nil, err
2687 }
2688 }
2689 args["first"] = arg2
2690 var arg3 *int
2691 if tmp, ok := rawArgs["last"]; ok {
2692 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
2693 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2694 if err != nil {
2695 return nil, err
2696 }
2697 }
2698 args["last"] = arg3
2699 return args, nil
2700}
2701
2702func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2703 var err error
2704 args := map[string]interface{}{}
2705 var arg0 *string
2706 if tmp, ok := rawArgs["after"]; ok {
2707 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
2708 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2709 if err != nil {
2710 return nil, err
2711 }
2712 }
2713 args["after"] = arg0
2714 var arg1 *string
2715 if tmp, ok := rawArgs["before"]; ok {
2716 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
2717 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2718 if err != nil {
2719 return nil, err
2720 }
2721 }
2722 args["before"] = arg1
2723 var arg2 *int
2724 if tmp, ok := rawArgs["first"]; ok {
2725 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
2726 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2727 if err != nil {
2728 return nil, err
2729 }
2730 }
2731 args["first"] = arg2
2732 var arg3 *int
2733 if tmp, ok := rawArgs["last"]; ok {
2734 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
2735 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2736 if err != nil {
2737 return nil, err
2738 }
2739 }
2740 args["last"] = arg3
2741 return args, nil
2742}
2743
2744func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2745 var err error
2746 args := map[string]interface{}{}
2747 var arg0 *string
2748 if tmp, ok := rawArgs["after"]; ok {
2749 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
2750 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2751 if err != nil {
2752 return nil, err
2753 }
2754 }
2755 args["after"] = arg0
2756 var arg1 *string
2757 if tmp, ok := rawArgs["before"]; ok {
2758 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
2759 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2760 if err != nil {
2761 return nil, err
2762 }
2763 }
2764 args["before"] = arg1
2765 var arg2 *int
2766 if tmp, ok := rawArgs["first"]; ok {
2767 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
2768 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2769 if err != nil {
2770 return nil, err
2771 }
2772 }
2773 args["first"] = arg2
2774 var arg3 *int
2775 if tmp, ok := rawArgs["last"]; ok {
2776 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
2777 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2778 if err != nil {
2779 return nil, err
2780 }
2781 }
2782 args["last"] = arg3
2783 return args, nil
2784}
2785
2786func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2787 var err error
2788 args := map[string]interface{}{}
2789 var arg0 *string
2790 if tmp, ok := rawArgs["after"]; ok {
2791 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
2792 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2793 if err != nil {
2794 return nil, err
2795 }
2796 }
2797 args["after"] = arg0
2798 var arg1 *string
2799 if tmp, ok := rawArgs["before"]; ok {
2800 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
2801 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2802 if err != nil {
2803 return nil, err
2804 }
2805 }
2806 args["before"] = arg1
2807 var arg2 *int
2808 if tmp, ok := rawArgs["first"]; ok {
2809 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
2810 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2811 if err != nil {
2812 return nil, err
2813 }
2814 }
2815 args["first"] = arg2
2816 var arg3 *int
2817 if tmp, ok := rawArgs["last"]; ok {
2818 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
2819 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2820 if err != nil {
2821 return nil, err
2822 }
2823 }
2824 args["last"] = arg3
2825 return args, nil
2826}
2827
2828func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2829 var err error
2830 args := map[string]interface{}{}
2831 var arg0 *string
2832 if tmp, ok := rawArgs["after"]; ok {
2833 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
2834 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2835 if err != nil {
2836 return nil, err
2837 }
2838 }
2839 args["after"] = arg0
2840 var arg1 *string
2841 if tmp, ok := rawArgs["before"]; ok {
2842 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
2843 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2844 if err != nil {
2845 return nil, err
2846 }
2847 }
2848 args["before"] = arg1
2849 var arg2 *int
2850 if tmp, ok := rawArgs["first"]; ok {
2851 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
2852 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2853 if err != nil {
2854 return nil, err
2855 }
2856 }
2857 args["first"] = arg2
2858 var arg3 *int
2859 if tmp, ok := rawArgs["last"]; ok {
2860 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
2861 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2862 if err != nil {
2863 return nil, err
2864 }
2865 }
2866 args["last"] = arg3
2867 return args, nil
2868}
2869
2870func (ec *executionContext) field_Mutation_addCommentAndClose_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2871 var err error
2872 args := map[string]interface{}{}
2873 var arg0 models.AddCommentAndCloseBugInput
2874 if tmp, ok := rawArgs["input"]; ok {
2875 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2876 arg0, err = ec.unmarshalNAddCommentAndCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugInput(ctx, tmp)
2877 if err != nil {
2878 return nil, err
2879 }
2880 }
2881 args["input"] = arg0
2882 return args, nil
2883}
2884
2885func (ec *executionContext) field_Mutation_addCommentAndReopen_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2886 var err error
2887 args := map[string]interface{}{}
2888 var arg0 models.AddCommentAndReopenBugInput
2889 if tmp, ok := rawArgs["input"]; ok {
2890 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2891 arg0, err = ec.unmarshalNAddCommentAndReopenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugInput(ctx, tmp)
2892 if err != nil {
2893 return nil, err
2894 }
2895 }
2896 args["input"] = arg0
2897 return args, nil
2898}
2899
2900func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2901 var err error
2902 args := map[string]interface{}{}
2903 var arg0 models.AddCommentInput
2904 if tmp, ok := rawArgs["input"]; ok {
2905 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2906 arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
2907 if err != nil {
2908 return nil, err
2909 }
2910 }
2911 args["input"] = arg0
2912 return args, nil
2913}
2914
2915func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2916 var err error
2917 args := map[string]interface{}{}
2918 var arg0 *models.ChangeLabelInput
2919 if tmp, ok := rawArgs["input"]; ok {
2920 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2921 arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
2922 if err != nil {
2923 return nil, err
2924 }
2925 }
2926 args["input"] = arg0
2927 return args, nil
2928}
2929
2930func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2931 var err error
2932 args := map[string]interface{}{}
2933 var arg0 models.CloseBugInput
2934 if tmp, ok := rawArgs["input"]; ok {
2935 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2936 arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
2937 if err != nil {
2938 return nil, err
2939 }
2940 }
2941 args["input"] = arg0
2942 return args, nil
2943}
2944
2945func (ec *executionContext) field_Mutation_editComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2946 var err error
2947 args := map[string]interface{}{}
2948 var arg0 models.EditCommentInput
2949 if tmp, ok := rawArgs["input"]; ok {
2950 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2951 arg0, err = ec.unmarshalNEditCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx, tmp)
2952 if err != nil {
2953 return nil, err
2954 }
2955 }
2956 args["input"] = arg0
2957 return args, nil
2958}
2959
2960func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2961 var err error
2962 args := map[string]interface{}{}
2963 var arg0 models.NewBugInput
2964 if tmp, ok := rawArgs["input"]; ok {
2965 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2966 arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
2967 if err != nil {
2968 return nil, err
2969 }
2970 }
2971 args["input"] = arg0
2972 return args, nil
2973}
2974
2975func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2976 var err error
2977 args := map[string]interface{}{}
2978 var arg0 models.OpenBugInput
2979 if tmp, ok := rawArgs["input"]; ok {
2980 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2981 arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
2982 if err != nil {
2983 return nil, err
2984 }
2985 }
2986 args["input"] = arg0
2987 return args, nil
2988}
2989
2990func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2991 var err error
2992 args := map[string]interface{}{}
2993 var arg0 models.SetTitleInput
2994 if tmp, ok := rawArgs["input"]; ok {
2995 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2996 arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
2997 if err != nil {
2998 return nil, err
2999 }
3000 }
3001 args["input"] = arg0
3002 return args, nil
3003}
3004
3005func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3006 var err error
3007 args := map[string]interface{}{}
3008 var arg0 string
3009 if tmp, ok := rawArgs["name"]; ok {
3010 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
3011 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3012 if err != nil {
3013 return nil, err
3014 }
3015 }
3016 args["name"] = arg0
3017 return args, nil
3018}
3019
3020func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3021 var err error
3022 args := map[string]interface{}{}
3023 var arg0 *string
3024 if tmp, ok := rawArgs["ref"]; ok {
3025 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref"))
3026 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3027 if err != nil {
3028 return nil, err
3029 }
3030 }
3031 args["ref"] = arg0
3032 return args, nil
3033}
3034
3035func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3036 var err error
3037 args := map[string]interface{}{}
3038 var arg0 *string
3039 if tmp, ok := rawArgs["after"]; ok {
3040 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
3041 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3042 if err != nil {
3043 return nil, err
3044 }
3045 }
3046 args["after"] = arg0
3047 var arg1 *string
3048 if tmp, ok := rawArgs["before"]; ok {
3049 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
3050 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3051 if err != nil {
3052 return nil, err
3053 }
3054 }
3055 args["before"] = arg1
3056 var arg2 *int
3057 if tmp, ok := rawArgs["first"]; ok {
3058 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
3059 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3060 if err != nil {
3061 return nil, err
3062 }
3063 }
3064 args["first"] = arg2
3065 var arg3 *int
3066 if tmp, ok := rawArgs["last"]; ok {
3067 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
3068 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3069 if err != nil {
3070 return nil, err
3071 }
3072 }
3073 args["last"] = arg3
3074 var arg4 *string
3075 if tmp, ok := rawArgs["query"]; ok {
3076 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("query"))
3077 arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3078 if err != nil {
3079 return nil, err
3080 }
3081 }
3082 args["query"] = arg4
3083 return args, nil
3084}
3085
3086func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3087 var err error
3088 args := map[string]interface{}{}
3089 var arg0 *string
3090 if tmp, ok := rawArgs["after"]; ok {
3091 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
3092 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3093 if err != nil {
3094 return nil, err
3095 }
3096 }
3097 args["after"] = arg0
3098 var arg1 *string
3099 if tmp, ok := rawArgs["before"]; ok {
3100 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
3101 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3102 if err != nil {
3103 return nil, err
3104 }
3105 }
3106 args["before"] = arg1
3107 var arg2 *int
3108 if tmp, ok := rawArgs["first"]; ok {
3109 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
3110 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3111 if err != nil {
3112 return nil, err
3113 }
3114 }
3115 args["first"] = arg2
3116 var arg3 *int
3117 if tmp, ok := rawArgs["last"]; ok {
3118 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
3119 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3120 if err != nil {
3121 return nil, err
3122 }
3123 }
3124 args["last"] = arg3
3125 return args, nil
3126}
3127
3128func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3129 var err error
3130 args := map[string]interface{}{}
3131 var arg0 string
3132 if tmp, ok := rawArgs["prefix"]; ok {
3133 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
3134 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3135 if err != nil {
3136 return nil, err
3137 }
3138 }
3139 args["prefix"] = arg0
3140 return args, nil
3141}
3142
3143func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3144 var err error
3145 args := map[string]interface{}{}
3146 var arg0 string
3147 if tmp, ok := rawArgs["prefix"]; ok {
3148 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
3149 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3150 if err != nil {
3151 return nil, err
3152 }
3153 }
3154 args["prefix"] = arg0
3155 return args, nil
3156}
3157
3158func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3159 var err error
3160 args := map[string]interface{}{}
3161 var arg0 *string
3162 if tmp, ok := rawArgs["after"]; ok {
3163 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
3164 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3165 if err != nil {
3166 return nil, err
3167 }
3168 }
3169 args["after"] = arg0
3170 var arg1 *string
3171 if tmp, ok := rawArgs["before"]; ok {
3172 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
3173 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3174 if err != nil {
3175 return nil, err
3176 }
3177 }
3178 args["before"] = arg1
3179 var arg2 *int
3180 if tmp, ok := rawArgs["first"]; ok {
3181 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
3182 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3183 if err != nil {
3184 return nil, err
3185 }
3186 }
3187 args["first"] = arg2
3188 var arg3 *int
3189 if tmp, ok := rawArgs["last"]; ok {
3190 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
3191 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3192 if err != nil {
3193 return nil, err
3194 }
3195 }
3196 args["last"] = arg3
3197 return args, nil
3198}
3199
3200func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3201 var err error
3202 args := map[string]interface{}{}
3203 var arg0 bool
3204 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3205 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
3206 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3207 if err != nil {
3208 return nil, err
3209 }
3210 }
3211 args["includeDeprecated"] = arg0
3212 return args, nil
3213}
3214
3215func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3216 var err error
3217 args := map[string]interface{}{}
3218 var arg0 bool
3219 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3220 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
3221 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3222 if err != nil {
3223 return nil, err
3224 }
3225 }
3226 args["includeDeprecated"] = arg0
3227 return args, nil
3228}
3229
3230// endregion ***************************** args.gotpl *****************************
3231
3232// region ************************** directives.gotpl **************************
3233
3234// endregion ************************** directives.gotpl **************************
3235
3236// region **************************** field.gotpl *****************************
3237
3238func (ec *executionContext) _AddCommentAndCloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3239 fc, err := ec.fieldContext_AddCommentAndCloseBugPayload_clientMutationId(ctx, field)
3240 if err != nil {
3241 return graphql.Null
3242 }
3243 ctx = graphql.WithFieldContext(ctx, fc)
3244 defer func() {
3245 if r := recover(); r != nil {
3246 ec.Error(ctx, ec.Recover(ctx, r))
3247 ret = graphql.Null
3248 }
3249 }()
3250 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3251 ctx = rctx // use context from middleware stack in children
3252 return obj.ClientMutationID, nil
3253 })
3254 if err != nil {
3255 ec.Error(ctx, err)
3256 return graphql.Null
3257 }
3258 if resTmp == nil {
3259 return graphql.Null
3260 }
3261 res := resTmp.(*string)
3262 fc.Result = res
3263 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3264}
3265
3266func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3267 fc = &graphql.FieldContext{
3268 Object: "AddCommentAndCloseBugPayload",
3269 Field: field,
3270 IsMethod: false,
3271 IsResolver: false,
3272 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3273 return nil, errors.New("field of type String does not have child fields")
3274 },
3275 }
3276 return fc, nil
3277}
3278
3279func (ec *executionContext) _AddCommentAndCloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3280 fc, err := ec.fieldContext_AddCommentAndCloseBugPayload_bug(ctx, field)
3281 if err != nil {
3282 return graphql.Null
3283 }
3284 ctx = graphql.WithFieldContext(ctx, fc)
3285 defer func() {
3286 if r := recover(); r != nil {
3287 ec.Error(ctx, ec.Recover(ctx, r))
3288 ret = graphql.Null
3289 }
3290 }()
3291 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3292 ctx = rctx // use context from middleware stack in children
3293 return obj.Bug, nil
3294 })
3295 if err != nil {
3296 ec.Error(ctx, err)
3297 return graphql.Null
3298 }
3299 if resTmp == nil {
3300 if !graphql.HasFieldError(ctx, fc) {
3301 ec.Errorf(ctx, "must not be null")
3302 }
3303 return graphql.Null
3304 }
3305 res := resTmp.(models.BugWrapper)
3306 fc.Result = res
3307 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
3308}
3309
3310func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3311 fc = &graphql.FieldContext{
3312 Object: "AddCommentAndCloseBugPayload",
3313 Field: field,
3314 IsMethod: false,
3315 IsResolver: false,
3316 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3317 switch field.Name {
3318 case "id":
3319 return ec.fieldContext_Bug_id(ctx, field)
3320 case "humanId":
3321 return ec.fieldContext_Bug_humanId(ctx, field)
3322 case "status":
3323 return ec.fieldContext_Bug_status(ctx, field)
3324 case "title":
3325 return ec.fieldContext_Bug_title(ctx, field)
3326 case "labels":
3327 return ec.fieldContext_Bug_labels(ctx, field)
3328 case "author":
3329 return ec.fieldContext_Bug_author(ctx, field)
3330 case "createdAt":
3331 return ec.fieldContext_Bug_createdAt(ctx, field)
3332 case "lastEdit":
3333 return ec.fieldContext_Bug_lastEdit(ctx, field)
3334 case "actors":
3335 return ec.fieldContext_Bug_actors(ctx, field)
3336 case "participants":
3337 return ec.fieldContext_Bug_participants(ctx, field)
3338 case "comments":
3339 return ec.fieldContext_Bug_comments(ctx, field)
3340 case "timeline":
3341 return ec.fieldContext_Bug_timeline(ctx, field)
3342 case "operations":
3343 return ec.fieldContext_Bug_operations(ctx, field)
3344 }
3345 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
3346 },
3347 }
3348 return fc, nil
3349}
3350
3351func (ec *executionContext) _AddCommentAndCloseBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3352 fc, err := ec.fieldContext_AddCommentAndCloseBugPayload_commentOperation(ctx, field)
3353 if err != nil {
3354 return graphql.Null
3355 }
3356 ctx = graphql.WithFieldContext(ctx, fc)
3357 defer func() {
3358 if r := recover(); r != nil {
3359 ec.Error(ctx, ec.Recover(ctx, r))
3360 ret = graphql.Null
3361 }
3362 }()
3363 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3364 ctx = rctx // use context from middleware stack in children
3365 return obj.CommentOperation, nil
3366 })
3367 if err != nil {
3368 ec.Error(ctx, err)
3369 return graphql.Null
3370 }
3371 if resTmp == nil {
3372 if !graphql.HasFieldError(ctx, fc) {
3373 ec.Errorf(ctx, "must not be null")
3374 }
3375 return graphql.Null
3376 }
3377 res := resTmp.(*bug.AddCommentOperation)
3378 fc.Result = res
3379 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3380}
3381
3382func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3383 fc = &graphql.FieldContext{
3384 Object: "AddCommentAndCloseBugPayload",
3385 Field: field,
3386 IsMethod: false,
3387 IsResolver: false,
3388 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3389 switch field.Name {
3390 case "id":
3391 return ec.fieldContext_AddCommentOperation_id(ctx, field)
3392 case "author":
3393 return ec.fieldContext_AddCommentOperation_author(ctx, field)
3394 case "date":
3395 return ec.fieldContext_AddCommentOperation_date(ctx, field)
3396 case "message":
3397 return ec.fieldContext_AddCommentOperation_message(ctx, field)
3398 case "files":
3399 return ec.fieldContext_AddCommentOperation_files(ctx, field)
3400 }
3401 return nil, fmt.Errorf("no field named %q was found under type AddCommentOperation", field.Name)
3402 },
3403 }
3404 return fc, nil
3405}
3406
3407func (ec *executionContext) _AddCommentAndCloseBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3408 fc, err := ec.fieldContext_AddCommentAndCloseBugPayload_statusOperation(ctx, field)
3409 if err != nil {
3410 return graphql.Null
3411 }
3412 ctx = graphql.WithFieldContext(ctx, fc)
3413 defer func() {
3414 if r := recover(); r != nil {
3415 ec.Error(ctx, ec.Recover(ctx, r))
3416 ret = graphql.Null
3417 }
3418 }()
3419 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3420 ctx = rctx // use context from middleware stack in children
3421 return obj.StatusOperation, nil
3422 })
3423 if err != nil {
3424 ec.Error(ctx, err)
3425 return graphql.Null
3426 }
3427 if resTmp == nil {
3428 if !graphql.HasFieldError(ctx, fc) {
3429 ec.Errorf(ctx, "must not be null")
3430 }
3431 return graphql.Null
3432 }
3433 res := resTmp.(*bug.SetStatusOperation)
3434 fc.Result = res
3435 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
3436}
3437
3438func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3439 fc = &graphql.FieldContext{
3440 Object: "AddCommentAndCloseBugPayload",
3441 Field: field,
3442 IsMethod: false,
3443 IsResolver: false,
3444 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3445 switch field.Name {
3446 case "id":
3447 return ec.fieldContext_SetStatusOperation_id(ctx, field)
3448 case "author":
3449 return ec.fieldContext_SetStatusOperation_author(ctx, field)
3450 case "date":
3451 return ec.fieldContext_SetStatusOperation_date(ctx, field)
3452 case "status":
3453 return ec.fieldContext_SetStatusOperation_status(ctx, field)
3454 }
3455 return nil, fmt.Errorf("no field named %q was found under type SetStatusOperation", field.Name)
3456 },
3457 }
3458 return fc, nil
3459}
3460
3461func (ec *executionContext) _AddCommentAndReopenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
3462 fc, err := ec.fieldContext_AddCommentAndReopenBugPayload_clientMutationId(ctx, field)
3463 if err != nil {
3464 return graphql.Null
3465 }
3466 ctx = graphql.WithFieldContext(ctx, fc)
3467 defer func() {
3468 if r := recover(); r != nil {
3469 ec.Error(ctx, ec.Recover(ctx, r))
3470 ret = graphql.Null
3471 }
3472 }()
3473 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3474 ctx = rctx // use context from middleware stack in children
3475 return obj.ClientMutationID, nil
3476 })
3477 if err != nil {
3478 ec.Error(ctx, err)
3479 return graphql.Null
3480 }
3481 if resTmp == nil {
3482 return graphql.Null
3483 }
3484 res := resTmp.(*string)
3485 fc.Result = res
3486 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3487}
3488
3489func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3490 fc = &graphql.FieldContext{
3491 Object: "AddCommentAndReopenBugPayload",
3492 Field: field,
3493 IsMethod: false,
3494 IsResolver: false,
3495 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3496 return nil, errors.New("field of type String does not have child fields")
3497 },
3498 }
3499 return fc, nil
3500}
3501
3502func (ec *executionContext) _AddCommentAndReopenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
3503 fc, err := ec.fieldContext_AddCommentAndReopenBugPayload_bug(ctx, field)
3504 if err != nil {
3505 return graphql.Null
3506 }
3507 ctx = graphql.WithFieldContext(ctx, fc)
3508 defer func() {
3509 if r := recover(); r != nil {
3510 ec.Error(ctx, ec.Recover(ctx, r))
3511 ret = graphql.Null
3512 }
3513 }()
3514 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3515 ctx = rctx // use context from middleware stack in children
3516 return obj.Bug, nil
3517 })
3518 if err != nil {
3519 ec.Error(ctx, err)
3520 return graphql.Null
3521 }
3522 if resTmp == nil {
3523 if !graphql.HasFieldError(ctx, fc) {
3524 ec.Errorf(ctx, "must not be null")
3525 }
3526 return graphql.Null
3527 }
3528 res := resTmp.(models.BugWrapper)
3529 fc.Result = res
3530 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
3531}
3532
3533func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3534 fc = &graphql.FieldContext{
3535 Object: "AddCommentAndReopenBugPayload",
3536 Field: field,
3537 IsMethod: false,
3538 IsResolver: false,
3539 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3540 switch field.Name {
3541 case "id":
3542 return ec.fieldContext_Bug_id(ctx, field)
3543 case "humanId":
3544 return ec.fieldContext_Bug_humanId(ctx, field)
3545 case "status":
3546 return ec.fieldContext_Bug_status(ctx, field)
3547 case "title":
3548 return ec.fieldContext_Bug_title(ctx, field)
3549 case "labels":
3550 return ec.fieldContext_Bug_labels(ctx, field)
3551 case "author":
3552 return ec.fieldContext_Bug_author(ctx, field)
3553 case "createdAt":
3554 return ec.fieldContext_Bug_createdAt(ctx, field)
3555 case "lastEdit":
3556 return ec.fieldContext_Bug_lastEdit(ctx, field)
3557 case "actors":
3558 return ec.fieldContext_Bug_actors(ctx, field)
3559 case "participants":
3560 return ec.fieldContext_Bug_participants(ctx, field)
3561 case "comments":
3562 return ec.fieldContext_Bug_comments(ctx, field)
3563 case "timeline":
3564 return ec.fieldContext_Bug_timeline(ctx, field)
3565 case "operations":
3566 return ec.fieldContext_Bug_operations(ctx, field)
3567 }
3568 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
3569 },
3570 }
3571 return fc, nil
3572}
3573
3574func (ec *executionContext) _AddCommentAndReopenBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
3575 fc, err := ec.fieldContext_AddCommentAndReopenBugPayload_commentOperation(ctx, field)
3576 if err != nil {
3577 return graphql.Null
3578 }
3579 ctx = graphql.WithFieldContext(ctx, fc)
3580 defer func() {
3581 if r := recover(); r != nil {
3582 ec.Error(ctx, ec.Recover(ctx, r))
3583 ret = graphql.Null
3584 }
3585 }()
3586 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3587 ctx = rctx // use context from middleware stack in children
3588 return obj.CommentOperation, nil
3589 })
3590 if err != nil {
3591 ec.Error(ctx, err)
3592 return graphql.Null
3593 }
3594 if resTmp == nil {
3595 if !graphql.HasFieldError(ctx, fc) {
3596 ec.Errorf(ctx, "must not be null")
3597 }
3598 return graphql.Null
3599 }
3600 res := resTmp.(*bug.AddCommentOperation)
3601 fc.Result = res
3602 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3603}
3604
3605func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3606 fc = &graphql.FieldContext{
3607 Object: "AddCommentAndReopenBugPayload",
3608 Field: field,
3609 IsMethod: false,
3610 IsResolver: false,
3611 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3612 switch field.Name {
3613 case "id":
3614 return ec.fieldContext_AddCommentOperation_id(ctx, field)
3615 case "author":
3616 return ec.fieldContext_AddCommentOperation_author(ctx, field)
3617 case "date":
3618 return ec.fieldContext_AddCommentOperation_date(ctx, field)
3619 case "message":
3620 return ec.fieldContext_AddCommentOperation_message(ctx, field)
3621 case "files":
3622 return ec.fieldContext_AddCommentOperation_files(ctx, field)
3623 }
3624 return nil, fmt.Errorf("no field named %q was found under type AddCommentOperation", field.Name)
3625 },
3626 }
3627 return fc, nil
3628}
3629
3630func (ec *executionContext) _AddCommentAndReopenBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
3631 fc, err := ec.fieldContext_AddCommentAndReopenBugPayload_statusOperation(ctx, field)
3632 if err != nil {
3633 return graphql.Null
3634 }
3635 ctx = graphql.WithFieldContext(ctx, fc)
3636 defer func() {
3637 if r := recover(); r != nil {
3638 ec.Error(ctx, ec.Recover(ctx, r))
3639 ret = graphql.Null
3640 }
3641 }()
3642 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3643 ctx = rctx // use context from middleware stack in children
3644 return obj.StatusOperation, nil
3645 })
3646 if err != nil {
3647 ec.Error(ctx, err)
3648 return graphql.Null
3649 }
3650 if resTmp == nil {
3651 if !graphql.HasFieldError(ctx, fc) {
3652 ec.Errorf(ctx, "must not be null")
3653 }
3654 return graphql.Null
3655 }
3656 res := resTmp.(*bug.SetStatusOperation)
3657 fc.Result = res
3658 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
3659}
3660
3661func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3662 fc = &graphql.FieldContext{
3663 Object: "AddCommentAndReopenBugPayload",
3664 Field: field,
3665 IsMethod: false,
3666 IsResolver: false,
3667 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3668 switch field.Name {
3669 case "id":
3670 return ec.fieldContext_SetStatusOperation_id(ctx, field)
3671 case "author":
3672 return ec.fieldContext_SetStatusOperation_author(ctx, field)
3673 case "date":
3674 return ec.fieldContext_SetStatusOperation_date(ctx, field)
3675 case "status":
3676 return ec.fieldContext_SetStatusOperation_status(ctx, field)
3677 }
3678 return nil, fmt.Errorf("no field named %q was found under type SetStatusOperation", field.Name)
3679 },
3680 }
3681 return fc, nil
3682}
3683
3684func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3685 fc, err := ec.fieldContext_AddCommentOperation_id(ctx, field)
3686 if err != nil {
3687 return graphql.Null
3688 }
3689 ctx = graphql.WithFieldContext(ctx, fc)
3690 defer func() {
3691 if r := recover(); r != nil {
3692 ec.Error(ctx, ec.Recover(ctx, r))
3693 ret = graphql.Null
3694 }
3695 }()
3696 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3697 ctx = rctx // use context from middleware stack in children
3698 return ec.resolvers.AddCommentOperation().ID(rctx, obj)
3699 })
3700 if err != nil {
3701 ec.Error(ctx, err)
3702 return graphql.Null
3703 }
3704 if resTmp == nil {
3705 if !graphql.HasFieldError(ctx, fc) {
3706 ec.Errorf(ctx, "must not be null")
3707 }
3708 return graphql.Null
3709 }
3710 res := resTmp.(string)
3711 fc.Result = res
3712 return ec.marshalNString2string(ctx, field.Selections, res)
3713}
3714
3715func (ec *executionContext) fieldContext_AddCommentOperation_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3716 fc = &graphql.FieldContext{
3717 Object: "AddCommentOperation",
3718 Field: field,
3719 IsMethod: true,
3720 IsResolver: true,
3721 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3722 return nil, errors.New("field of type String does not have child fields")
3723 },
3724 }
3725 return fc, nil
3726}
3727
3728func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3729 fc, err := ec.fieldContext_AddCommentOperation_author(ctx, field)
3730 if err != nil {
3731 return graphql.Null
3732 }
3733 ctx = graphql.WithFieldContext(ctx, fc)
3734 defer func() {
3735 if r := recover(); r != nil {
3736 ec.Error(ctx, ec.Recover(ctx, r))
3737 ret = graphql.Null
3738 }
3739 }()
3740 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3741 ctx = rctx // use context from middleware stack in children
3742 return ec.resolvers.AddCommentOperation().Author(rctx, obj)
3743 })
3744 if err != nil {
3745 ec.Error(ctx, err)
3746 return graphql.Null
3747 }
3748 if resTmp == nil {
3749 if !graphql.HasFieldError(ctx, fc) {
3750 ec.Errorf(ctx, "must not be null")
3751 }
3752 return graphql.Null
3753 }
3754 res := resTmp.(models.IdentityWrapper)
3755 fc.Result = res
3756 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3757}
3758
3759func (ec *executionContext) fieldContext_AddCommentOperation_author(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3760 fc = &graphql.FieldContext{
3761 Object: "AddCommentOperation",
3762 Field: field,
3763 IsMethod: true,
3764 IsResolver: true,
3765 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3766 switch field.Name {
3767 case "id":
3768 return ec.fieldContext_Identity_id(ctx, field)
3769 case "humanId":
3770 return ec.fieldContext_Identity_humanId(ctx, field)
3771 case "name":
3772 return ec.fieldContext_Identity_name(ctx, field)
3773 case "email":
3774 return ec.fieldContext_Identity_email(ctx, field)
3775 case "login":
3776 return ec.fieldContext_Identity_login(ctx, field)
3777 case "displayName":
3778 return ec.fieldContext_Identity_displayName(ctx, field)
3779 case "avatarUrl":
3780 return ec.fieldContext_Identity_avatarUrl(ctx, field)
3781 case "isProtected":
3782 return ec.fieldContext_Identity_isProtected(ctx, field)
3783 }
3784 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
3785 },
3786 }
3787 return fc, nil
3788}
3789
3790func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3791 fc, err := ec.fieldContext_AddCommentOperation_date(ctx, field)
3792 if err != nil {
3793 return graphql.Null
3794 }
3795 ctx = graphql.WithFieldContext(ctx, fc)
3796 defer func() {
3797 if r := recover(); r != nil {
3798 ec.Error(ctx, ec.Recover(ctx, r))
3799 ret = graphql.Null
3800 }
3801 }()
3802 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3803 ctx = rctx // use context from middleware stack in children
3804 return ec.resolvers.AddCommentOperation().Date(rctx, obj)
3805 })
3806 if err != nil {
3807 ec.Error(ctx, err)
3808 return graphql.Null
3809 }
3810 if resTmp == nil {
3811 if !graphql.HasFieldError(ctx, fc) {
3812 ec.Errorf(ctx, "must not be null")
3813 }
3814 return graphql.Null
3815 }
3816 res := resTmp.(*time.Time)
3817 fc.Result = res
3818 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3819}
3820
3821func (ec *executionContext) fieldContext_AddCommentOperation_date(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3822 fc = &graphql.FieldContext{
3823 Object: "AddCommentOperation",
3824 Field: field,
3825 IsMethod: true,
3826 IsResolver: true,
3827 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3828 return nil, errors.New("field of type Time does not have child fields")
3829 },
3830 }
3831 return fc, nil
3832}
3833
3834func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3835 fc, err := ec.fieldContext_AddCommentOperation_message(ctx, field)
3836 if err != nil {
3837 return graphql.Null
3838 }
3839 ctx = graphql.WithFieldContext(ctx, fc)
3840 defer func() {
3841 if r := recover(); r != nil {
3842 ec.Error(ctx, ec.Recover(ctx, r))
3843 ret = graphql.Null
3844 }
3845 }()
3846 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3847 ctx = rctx // use context from middleware stack in children
3848 return obj.Message, nil
3849 })
3850 if err != nil {
3851 ec.Error(ctx, err)
3852 return graphql.Null
3853 }
3854 if resTmp == nil {
3855 if !graphql.HasFieldError(ctx, fc) {
3856 ec.Errorf(ctx, "must not be null")
3857 }
3858 return graphql.Null
3859 }
3860 res := resTmp.(string)
3861 fc.Result = res
3862 return ec.marshalNString2string(ctx, field.Selections, res)
3863}
3864
3865func (ec *executionContext) fieldContext_AddCommentOperation_message(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3866 fc = &graphql.FieldContext{
3867 Object: "AddCommentOperation",
3868 Field: field,
3869 IsMethod: false,
3870 IsResolver: false,
3871 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3872 return nil, errors.New("field of type String does not have child fields")
3873 },
3874 }
3875 return fc, nil
3876}
3877
3878func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3879 fc, err := ec.fieldContext_AddCommentOperation_files(ctx, field)
3880 if err != nil {
3881 return graphql.Null
3882 }
3883 ctx = graphql.WithFieldContext(ctx, fc)
3884 defer func() {
3885 if r := recover(); r != nil {
3886 ec.Error(ctx, ec.Recover(ctx, r))
3887 ret = graphql.Null
3888 }
3889 }()
3890 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3891 ctx = rctx // use context from middleware stack in children
3892 return obj.Files, nil
3893 })
3894 if err != nil {
3895 ec.Error(ctx, err)
3896 return graphql.Null
3897 }
3898 if resTmp == nil {
3899 if !graphql.HasFieldError(ctx, fc) {
3900 ec.Errorf(ctx, "must not be null")
3901 }
3902 return graphql.Null
3903 }
3904 res := resTmp.([]repository.Hash)
3905 fc.Result = res
3906 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
3907}
3908
3909func (ec *executionContext) fieldContext_AddCommentOperation_files(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3910 fc = &graphql.FieldContext{
3911 Object: "AddCommentOperation",
3912 Field: field,
3913 IsMethod: false,
3914 IsResolver: false,
3915 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3916 return nil, errors.New("field of type Hash does not have child fields")
3917 },
3918 }
3919 return fc, nil
3920}
3921
3922func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3923 fc, err := ec.fieldContext_AddCommentPayload_clientMutationId(ctx, field)
3924 if err != nil {
3925 return graphql.Null
3926 }
3927 ctx = graphql.WithFieldContext(ctx, fc)
3928 defer func() {
3929 if r := recover(); r != nil {
3930 ec.Error(ctx, ec.Recover(ctx, r))
3931 ret = graphql.Null
3932 }
3933 }()
3934 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3935 ctx = rctx // use context from middleware stack in children
3936 return obj.ClientMutationID, nil
3937 })
3938 if err != nil {
3939 ec.Error(ctx, err)
3940 return graphql.Null
3941 }
3942 if resTmp == nil {
3943 return graphql.Null
3944 }
3945 res := resTmp.(*string)
3946 fc.Result = res
3947 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3948}
3949
3950func (ec *executionContext) fieldContext_AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3951 fc = &graphql.FieldContext{
3952 Object: "AddCommentPayload",
3953 Field: field,
3954 IsMethod: false,
3955 IsResolver: false,
3956 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3957 return nil, errors.New("field of type String does not have child fields")
3958 },
3959 }
3960 return fc, nil
3961}
3962
3963func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3964 fc, err := ec.fieldContext_AddCommentPayload_bug(ctx, field)
3965 if err != nil {
3966 return graphql.Null
3967 }
3968 ctx = graphql.WithFieldContext(ctx, fc)
3969 defer func() {
3970 if r := recover(); r != nil {
3971 ec.Error(ctx, ec.Recover(ctx, r))
3972 ret = graphql.Null
3973 }
3974 }()
3975 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3976 ctx = rctx // use context from middleware stack in children
3977 return obj.Bug, nil
3978 })
3979 if err != nil {
3980 ec.Error(ctx, err)
3981 return graphql.Null
3982 }
3983 if resTmp == nil {
3984 if !graphql.HasFieldError(ctx, fc) {
3985 ec.Errorf(ctx, "must not be null")
3986 }
3987 return graphql.Null
3988 }
3989 res := resTmp.(models.BugWrapper)
3990 fc.Result = res
3991 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
3992}
3993
3994func (ec *executionContext) fieldContext_AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3995 fc = &graphql.FieldContext{
3996 Object: "AddCommentPayload",
3997 Field: field,
3998 IsMethod: false,
3999 IsResolver: false,
4000 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4001 switch field.Name {
4002 case "id":
4003 return ec.fieldContext_Bug_id(ctx, field)
4004 case "humanId":
4005 return ec.fieldContext_Bug_humanId(ctx, field)
4006 case "status":
4007 return ec.fieldContext_Bug_status(ctx, field)
4008 case "title":
4009 return ec.fieldContext_Bug_title(ctx, field)
4010 case "labels":
4011 return ec.fieldContext_Bug_labels(ctx, field)
4012 case "author":
4013 return ec.fieldContext_Bug_author(ctx, field)
4014 case "createdAt":
4015 return ec.fieldContext_Bug_createdAt(ctx, field)
4016 case "lastEdit":
4017 return ec.fieldContext_Bug_lastEdit(ctx, field)
4018 case "actors":
4019 return ec.fieldContext_Bug_actors(ctx, field)
4020 case "participants":
4021 return ec.fieldContext_Bug_participants(ctx, field)
4022 case "comments":
4023 return ec.fieldContext_Bug_comments(ctx, field)
4024 case "timeline":
4025 return ec.fieldContext_Bug_timeline(ctx, field)
4026 case "operations":
4027 return ec.fieldContext_Bug_operations(ctx, field)
4028 }
4029 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
4030 },
4031 }
4032 return fc, nil
4033}
4034
4035func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
4036 fc, err := ec.fieldContext_AddCommentPayload_operation(ctx, field)
4037 if err != nil {
4038 return graphql.Null
4039 }
4040 ctx = graphql.WithFieldContext(ctx, fc)
4041 defer func() {
4042 if r := recover(); r != nil {
4043 ec.Error(ctx, ec.Recover(ctx, r))
4044 ret = graphql.Null
4045 }
4046 }()
4047 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4048 ctx = rctx // use context from middleware stack in children
4049 return obj.Operation, nil
4050 })
4051 if err != nil {
4052 ec.Error(ctx, err)
4053 return graphql.Null
4054 }
4055 if resTmp == nil {
4056 if !graphql.HasFieldError(ctx, fc) {
4057 ec.Errorf(ctx, "must not be null")
4058 }
4059 return graphql.Null
4060 }
4061 res := resTmp.(*bug.AddCommentOperation)
4062 fc.Result = res
4063 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
4064}
4065
4066func (ec *executionContext) fieldContext_AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4067 fc = &graphql.FieldContext{
4068 Object: "AddCommentPayload",
4069 Field: field,
4070 IsMethod: false,
4071 IsResolver: false,
4072 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4073 switch field.Name {
4074 case "id":
4075 return ec.fieldContext_AddCommentOperation_id(ctx, field)
4076 case "author":
4077 return ec.fieldContext_AddCommentOperation_author(ctx, field)
4078 case "date":
4079 return ec.fieldContext_AddCommentOperation_date(ctx, field)
4080 case "message":
4081 return ec.fieldContext_AddCommentOperation_message(ctx, field)
4082 case "files":
4083 return ec.fieldContext_AddCommentOperation_files(ctx, field)
4084 }
4085 return nil, fmt.Errorf("no field named %q was found under type AddCommentOperation", field.Name)
4086 },
4087 }
4088 return fc, nil
4089}
4090
4091func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
4092 fc, err := ec.fieldContext_AddCommentTimelineItem_id(ctx, field)
4093 if err != nil {
4094 return graphql.Null
4095 }
4096 ctx = graphql.WithFieldContext(ctx, fc)
4097 defer func() {
4098 if r := recover(); r != nil {
4099 ec.Error(ctx, ec.Recover(ctx, r))
4100 ret = graphql.Null
4101 }
4102 }()
4103 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4104 ctx = rctx // use context from middleware stack in children
4105 return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
4106 })
4107 if err != nil {
4108 ec.Error(ctx, err)
4109 return graphql.Null
4110 }
4111 if resTmp == nil {
4112 if !graphql.HasFieldError(ctx, fc) {
4113 ec.Errorf(ctx, "must not be null")
4114 }
4115 return graphql.Null
4116 }
4117 res := resTmp.(string)
4118 fc.Result = res
4119 return ec.marshalNString2string(ctx, field.Selections, res)
4120}
4121
4122func (ec *executionContext) fieldContext_AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4123 fc = &graphql.FieldContext{
4124 Object: "AddCommentTimelineItem",
4125 Field: field,
4126 IsMethod: true,
4127 IsResolver: true,
4128 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4129 return nil, errors.New("field of type String does not have child fields")
4130 },
4131 }
4132 return fc, nil
4133}
4134
4135func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
4136 fc, err := ec.fieldContext_AddCommentTimelineItem_author(ctx, field)
4137 if err != nil {
4138 return graphql.Null
4139 }
4140 ctx = graphql.WithFieldContext(ctx, fc)
4141 defer func() {
4142 if r := recover(); r != nil {
4143 ec.Error(ctx, ec.Recover(ctx, r))
4144 ret = graphql.Null
4145 }
4146 }()
4147 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4148 ctx = rctx // use context from middleware stack in children
4149 return ec.resolvers.AddCommentTimelineItem().Author(rctx, obj)
4150 })
4151 if err != nil {
4152 ec.Error(ctx, err)
4153 return graphql.Null
4154 }
4155 if resTmp == nil {
4156 if !graphql.HasFieldError(ctx, fc) {
4157 ec.Errorf(ctx, "must not be null")
4158 }
4159 return graphql.Null
4160 }
4161 res := resTmp.(models.IdentityWrapper)
4162 fc.Result = res
4163 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
4164}
4165
4166func (ec *executionContext) fieldContext_AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4167 fc = &graphql.FieldContext{
4168 Object: "AddCommentTimelineItem",
4169 Field: field,
4170 IsMethod: true,
4171 IsResolver: true,
4172 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4173 switch field.Name {
4174 case "id":
4175 return ec.fieldContext_Identity_id(ctx, field)
4176 case "humanId":
4177 return ec.fieldContext_Identity_humanId(ctx, field)
4178 case "name":
4179 return ec.fieldContext_Identity_name(ctx, field)
4180 case "email":
4181 return ec.fieldContext_Identity_email(ctx, field)
4182 case "login":
4183 return ec.fieldContext_Identity_login(ctx, field)
4184 case "displayName":
4185 return ec.fieldContext_Identity_displayName(ctx, field)
4186 case "avatarUrl":
4187 return ec.fieldContext_Identity_avatarUrl(ctx, field)
4188 case "isProtected":
4189 return ec.fieldContext_Identity_isProtected(ctx, field)
4190 }
4191 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
4192 },
4193 }
4194 return fc, nil
4195}
4196
4197func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
4198 fc, err := ec.fieldContext_AddCommentTimelineItem_message(ctx, field)
4199 if err != nil {
4200 return graphql.Null
4201 }
4202 ctx = graphql.WithFieldContext(ctx, fc)
4203 defer func() {
4204 if r := recover(); r != nil {
4205 ec.Error(ctx, ec.Recover(ctx, r))
4206 ret = graphql.Null
4207 }
4208 }()
4209 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4210 ctx = rctx // use context from middleware stack in children
4211 return obj.Message, nil
4212 })
4213 if err != nil {
4214 ec.Error(ctx, err)
4215 return graphql.Null
4216 }
4217 if resTmp == nil {
4218 if !graphql.HasFieldError(ctx, fc) {
4219 ec.Errorf(ctx, "must not be null")
4220 }
4221 return graphql.Null
4222 }
4223 res := resTmp.(string)
4224 fc.Result = res
4225 return ec.marshalNString2string(ctx, field.Selections, res)
4226}
4227
4228func (ec *executionContext) fieldContext_AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4229 fc = &graphql.FieldContext{
4230 Object: "AddCommentTimelineItem",
4231 Field: field,
4232 IsMethod: false,
4233 IsResolver: false,
4234 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4235 return nil, errors.New("field of type String does not have child fields")
4236 },
4237 }
4238 return fc, nil
4239}
4240
4241func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
4242 fc, err := ec.fieldContext_AddCommentTimelineItem_messageIsEmpty(ctx, field)
4243 if err != nil {
4244 return graphql.Null
4245 }
4246 ctx = graphql.WithFieldContext(ctx, fc)
4247 defer func() {
4248 if r := recover(); r != nil {
4249 ec.Error(ctx, ec.Recover(ctx, r))
4250 ret = graphql.Null
4251 }
4252 }()
4253 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4254 ctx = rctx // use context from middleware stack in children
4255 return obj.MessageIsEmpty(), nil
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.(bool)
4268 fc.Result = res
4269 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
4270}
4271
4272func (ec *executionContext) fieldContext_AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4273 fc = &graphql.FieldContext{
4274 Object: "AddCommentTimelineItem",
4275 Field: field,
4276 IsMethod: true,
4277 IsResolver: false,
4278 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4279 return nil, errors.New("field of type Boolean does not have child fields")
4280 },
4281 }
4282 return fc, nil
4283}
4284
4285func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
4286 fc, err := ec.fieldContext_AddCommentTimelineItem_files(ctx, field)
4287 if err != nil {
4288 return graphql.Null
4289 }
4290 ctx = graphql.WithFieldContext(ctx, fc)
4291 defer func() {
4292 if r := recover(); r != nil {
4293 ec.Error(ctx, ec.Recover(ctx, r))
4294 ret = graphql.Null
4295 }
4296 }()
4297 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4298 ctx = rctx // use context from middleware stack in children
4299 return obj.Files, nil
4300 })
4301 if err != nil {
4302 ec.Error(ctx, err)
4303 return graphql.Null
4304 }
4305 if resTmp == nil {
4306 if !graphql.HasFieldError(ctx, fc) {
4307 ec.Errorf(ctx, "must not be null")
4308 }
4309 return graphql.Null
4310 }
4311 res := resTmp.([]repository.Hash)
4312 fc.Result = res
4313 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
4314}
4315
4316func (ec *executionContext) fieldContext_AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4317 fc = &graphql.FieldContext{
4318 Object: "AddCommentTimelineItem",
4319 Field: field,
4320 IsMethod: false,
4321 IsResolver: false,
4322 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4323 return nil, errors.New("field of type Hash does not have child fields")
4324 },
4325 }
4326 return fc, nil
4327}
4328
4329func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
4330 fc, err := ec.fieldContext_AddCommentTimelineItem_createdAt(ctx, field)
4331 if err != nil {
4332 return graphql.Null
4333 }
4334 ctx = graphql.WithFieldContext(ctx, fc)
4335 defer func() {
4336 if r := recover(); r != nil {
4337 ec.Error(ctx, ec.Recover(ctx, r))
4338 ret = graphql.Null
4339 }
4340 }()
4341 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4342 ctx = rctx // use context from middleware stack in children
4343 return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
4344 })
4345 if err != nil {
4346 ec.Error(ctx, err)
4347 return graphql.Null
4348 }
4349 if resTmp == nil {
4350 if !graphql.HasFieldError(ctx, fc) {
4351 ec.Errorf(ctx, "must not be null")
4352 }
4353 return graphql.Null
4354 }
4355 res := resTmp.(*time.Time)
4356 fc.Result = res
4357 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
4358}
4359
4360func (ec *executionContext) fieldContext_AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4361 fc = &graphql.FieldContext{
4362 Object: "AddCommentTimelineItem",
4363 Field: field,
4364 IsMethod: true,
4365 IsResolver: true,
4366 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4367 return nil, errors.New("field of type Time does not have child fields")
4368 },
4369 }
4370 return fc, nil
4371}
4372
4373func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
4374 fc, err := ec.fieldContext_AddCommentTimelineItem_lastEdit(ctx, field)
4375 if err != nil {
4376 return graphql.Null
4377 }
4378 ctx = graphql.WithFieldContext(ctx, fc)
4379 defer func() {
4380 if r := recover(); r != nil {
4381 ec.Error(ctx, ec.Recover(ctx, r))
4382 ret = graphql.Null
4383 }
4384 }()
4385 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4386 ctx = rctx // use context from middleware stack in children
4387 return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
4388 })
4389 if err != nil {
4390 ec.Error(ctx, err)
4391 return graphql.Null
4392 }
4393 if resTmp == nil {
4394 if !graphql.HasFieldError(ctx, fc) {
4395 ec.Errorf(ctx, "must not be null")
4396 }
4397 return graphql.Null
4398 }
4399 res := resTmp.(*time.Time)
4400 fc.Result = res
4401 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
4402}
4403
4404func (ec *executionContext) fieldContext_AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4405 fc = &graphql.FieldContext{
4406 Object: "AddCommentTimelineItem",
4407 Field: field,
4408 IsMethod: true,
4409 IsResolver: true,
4410 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4411 return nil, errors.New("field of type Time does not have child fields")
4412 },
4413 }
4414 return fc, nil
4415}
4416
4417func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
4418 fc, err := ec.fieldContext_AddCommentTimelineItem_edited(ctx, field)
4419 if err != nil {
4420 return graphql.Null
4421 }
4422 ctx = graphql.WithFieldContext(ctx, fc)
4423 defer func() {
4424 if r := recover(); r != nil {
4425 ec.Error(ctx, ec.Recover(ctx, r))
4426 ret = graphql.Null
4427 }
4428 }()
4429 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4430 ctx = rctx // use context from middleware stack in children
4431 return obj.Edited(), nil
4432 })
4433 if err != nil {
4434 ec.Error(ctx, err)
4435 return graphql.Null
4436 }
4437 if resTmp == nil {
4438 if !graphql.HasFieldError(ctx, fc) {
4439 ec.Errorf(ctx, "must not be null")
4440 }
4441 return graphql.Null
4442 }
4443 res := resTmp.(bool)
4444 fc.Result = res
4445 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
4446}
4447
4448func (ec *executionContext) fieldContext_AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4449 fc = &graphql.FieldContext{
4450 Object: "AddCommentTimelineItem",
4451 Field: field,
4452 IsMethod: true,
4453 IsResolver: false,
4454 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4455 return nil, errors.New("field of type Boolean does not have child fields")
4456 },
4457 }
4458 return fc, nil
4459}
4460
4461func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
4462 fc, err := ec.fieldContext_AddCommentTimelineItem_history(ctx, field)
4463 if err != nil {
4464 return graphql.Null
4465 }
4466 ctx = graphql.WithFieldContext(ctx, fc)
4467 defer func() {
4468 if r := recover(); r != nil {
4469 ec.Error(ctx, ec.Recover(ctx, r))
4470 ret = graphql.Null
4471 }
4472 }()
4473 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4474 ctx = rctx // use context from middleware stack in children
4475 return obj.History, nil
4476 })
4477 if err != nil {
4478 ec.Error(ctx, err)
4479 return graphql.Null
4480 }
4481 if resTmp == nil {
4482 if !graphql.HasFieldError(ctx, fc) {
4483 ec.Errorf(ctx, "must not be null")
4484 }
4485 return graphql.Null
4486 }
4487 res := resTmp.([]bug.CommentHistoryStep)
4488 fc.Result = res
4489 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
4490}
4491
4492func (ec *executionContext) fieldContext_AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4493 fc = &graphql.FieldContext{
4494 Object: "AddCommentTimelineItem",
4495 Field: field,
4496 IsMethod: false,
4497 IsResolver: false,
4498 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4499 switch field.Name {
4500 case "message":
4501 return ec.fieldContext_CommentHistoryStep_message(ctx, field)
4502 case "date":
4503 return ec.fieldContext_CommentHistoryStep_date(ctx, field)
4504 }
4505 return nil, fmt.Errorf("no field named %q was found under type CommentHistoryStep", field.Name)
4506 },
4507 }
4508 return fc, nil
4509}
4510
4511func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4512 fc, err := ec.fieldContext_Bug_id(ctx, field)
4513 if err != nil {
4514 return graphql.Null
4515 }
4516 ctx = graphql.WithFieldContext(ctx, fc)
4517 defer func() {
4518 if r := recover(); r != nil {
4519 ec.Error(ctx, ec.Recover(ctx, r))
4520 ret = graphql.Null
4521 }
4522 }()
4523 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4524 ctx = rctx // use context from middleware stack in children
4525 return ec.resolvers.Bug().ID(rctx, obj)
4526 })
4527 if err != nil {
4528 ec.Error(ctx, err)
4529 return graphql.Null
4530 }
4531 if resTmp == nil {
4532 if !graphql.HasFieldError(ctx, fc) {
4533 ec.Errorf(ctx, "must not be null")
4534 }
4535 return graphql.Null
4536 }
4537 res := resTmp.(string)
4538 fc.Result = res
4539 return ec.marshalNString2string(ctx, field.Selections, res)
4540}
4541
4542func (ec *executionContext) fieldContext_Bug_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4543 fc = &graphql.FieldContext{
4544 Object: "Bug",
4545 Field: field,
4546 IsMethod: true,
4547 IsResolver: true,
4548 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4549 return nil, errors.New("field of type String does not have child fields")
4550 },
4551 }
4552 return fc, nil
4553}
4554
4555func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4556 fc, err := ec.fieldContext_Bug_humanId(ctx, field)
4557 if err != nil {
4558 return graphql.Null
4559 }
4560 ctx = graphql.WithFieldContext(ctx, fc)
4561 defer func() {
4562 if r := recover(); r != nil {
4563 ec.Error(ctx, ec.Recover(ctx, r))
4564 ret = graphql.Null
4565 }
4566 }()
4567 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4568 ctx = rctx // use context from middleware stack in children
4569 return ec.resolvers.Bug().HumanID(rctx, obj)
4570 })
4571 if err != nil {
4572 ec.Error(ctx, err)
4573 return graphql.Null
4574 }
4575 if resTmp == nil {
4576 if !graphql.HasFieldError(ctx, fc) {
4577 ec.Errorf(ctx, "must not be null")
4578 }
4579 return graphql.Null
4580 }
4581 res := resTmp.(string)
4582 fc.Result = res
4583 return ec.marshalNString2string(ctx, field.Selections, res)
4584}
4585
4586func (ec *executionContext) fieldContext_Bug_humanId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4587 fc = &graphql.FieldContext{
4588 Object: "Bug",
4589 Field: field,
4590 IsMethod: true,
4591 IsResolver: true,
4592 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4593 return nil, errors.New("field of type String does not have child fields")
4594 },
4595 }
4596 return fc, nil
4597}
4598
4599func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4600 fc, err := ec.fieldContext_Bug_status(ctx, field)
4601 if err != nil {
4602 return graphql.Null
4603 }
4604 ctx = graphql.WithFieldContext(ctx, fc)
4605 defer func() {
4606 if r := recover(); r != nil {
4607 ec.Error(ctx, ec.Recover(ctx, r))
4608 ret = graphql.Null
4609 }
4610 }()
4611 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4612 ctx = rctx // use context from middleware stack in children
4613 return ec.resolvers.Bug().Status(rctx, obj)
4614 })
4615 if err != nil {
4616 ec.Error(ctx, err)
4617 return graphql.Null
4618 }
4619 if resTmp == nil {
4620 if !graphql.HasFieldError(ctx, fc) {
4621 ec.Errorf(ctx, "must not be null")
4622 }
4623 return graphql.Null
4624 }
4625 res := resTmp.(models.Status)
4626 fc.Result = res
4627 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
4628}
4629
4630func (ec *executionContext) fieldContext_Bug_status(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4631 fc = &graphql.FieldContext{
4632 Object: "Bug",
4633 Field: field,
4634 IsMethod: true,
4635 IsResolver: true,
4636 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4637 return nil, errors.New("field of type Status does not have child fields")
4638 },
4639 }
4640 return fc, nil
4641}
4642
4643func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4644 fc, err := ec.fieldContext_Bug_title(ctx, field)
4645 if err != nil {
4646 return graphql.Null
4647 }
4648 ctx = graphql.WithFieldContext(ctx, fc)
4649 defer func() {
4650 if r := recover(); r != nil {
4651 ec.Error(ctx, ec.Recover(ctx, r))
4652 ret = graphql.Null
4653 }
4654 }()
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.Title(), 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.(string)
4670 fc.Result = res
4671 return ec.marshalNString2string(ctx, field.Selections, res)
4672}
4673
4674func (ec *executionContext) fieldContext_Bug_title(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4675 fc = &graphql.FieldContext{
4676 Object: "Bug",
4677 Field: field,
4678 IsMethod: true,
4679 IsResolver: false,
4680 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4681 return nil, errors.New("field of type String does not have child fields")
4682 },
4683 }
4684 return fc, nil
4685}
4686
4687func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4688 fc, err := ec.fieldContext_Bug_labels(ctx, field)
4689 if err != nil {
4690 return graphql.Null
4691 }
4692 ctx = graphql.WithFieldContext(ctx, fc)
4693 defer func() {
4694 if r := recover(); r != nil {
4695 ec.Error(ctx, ec.Recover(ctx, r))
4696 ret = graphql.Null
4697 }
4698 }()
4699 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4700 ctx = rctx // use context from middleware stack in children
4701 return obj.Labels(), nil
4702 })
4703 if err != nil {
4704 ec.Error(ctx, err)
4705 return graphql.Null
4706 }
4707 if resTmp == nil {
4708 if !graphql.HasFieldError(ctx, fc) {
4709 ec.Errorf(ctx, "must not be null")
4710 }
4711 return graphql.Null
4712 }
4713 res := resTmp.([]bug.Label)
4714 fc.Result = res
4715 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
4716}
4717
4718func (ec *executionContext) fieldContext_Bug_labels(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4719 fc = &graphql.FieldContext{
4720 Object: "Bug",
4721 Field: field,
4722 IsMethod: true,
4723 IsResolver: false,
4724 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4725 switch field.Name {
4726 case "name":
4727 return ec.fieldContext_Label_name(ctx, field)
4728 case "color":
4729 return ec.fieldContext_Label_color(ctx, field)
4730 }
4731 return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
4732 },
4733 }
4734 return fc, nil
4735}
4736
4737func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4738 fc, err := ec.fieldContext_Bug_author(ctx, field)
4739 if err != nil {
4740 return graphql.Null
4741 }
4742 ctx = graphql.WithFieldContext(ctx, fc)
4743 defer func() {
4744 if r := recover(); r != nil {
4745 ec.Error(ctx, ec.Recover(ctx, r))
4746 ret = graphql.Null
4747 }
4748 }()
4749 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4750 ctx = rctx // use context from middleware stack in children
4751 return obj.Author()
4752 })
4753 if err != nil {
4754 ec.Error(ctx, err)
4755 return graphql.Null
4756 }
4757 if resTmp == nil {
4758 if !graphql.HasFieldError(ctx, fc) {
4759 ec.Errorf(ctx, "must not be null")
4760 }
4761 return graphql.Null
4762 }
4763 res := resTmp.(models.IdentityWrapper)
4764 fc.Result = res
4765 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
4766}
4767
4768func (ec *executionContext) fieldContext_Bug_author(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4769 fc = &graphql.FieldContext{
4770 Object: "Bug",
4771 Field: field,
4772 IsMethod: true,
4773 IsResolver: false,
4774 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4775 switch field.Name {
4776 case "id":
4777 return ec.fieldContext_Identity_id(ctx, field)
4778 case "humanId":
4779 return ec.fieldContext_Identity_humanId(ctx, field)
4780 case "name":
4781 return ec.fieldContext_Identity_name(ctx, field)
4782 case "email":
4783 return ec.fieldContext_Identity_email(ctx, field)
4784 case "login":
4785 return ec.fieldContext_Identity_login(ctx, field)
4786 case "displayName":
4787 return ec.fieldContext_Identity_displayName(ctx, field)
4788 case "avatarUrl":
4789 return ec.fieldContext_Identity_avatarUrl(ctx, field)
4790 case "isProtected":
4791 return ec.fieldContext_Identity_isProtected(ctx, field)
4792 }
4793 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
4794 },
4795 }
4796 return fc, nil
4797}
4798
4799func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4800 fc, err := ec.fieldContext_Bug_createdAt(ctx, field)
4801 if err != nil {
4802 return graphql.Null
4803 }
4804 ctx = graphql.WithFieldContext(ctx, fc)
4805 defer func() {
4806 if r := recover(); r != nil {
4807 ec.Error(ctx, ec.Recover(ctx, r))
4808 ret = graphql.Null
4809 }
4810 }()
4811 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4812 ctx = rctx // use context from middleware stack in children
4813 return obj.CreatedAt(), nil
4814 })
4815 if err != nil {
4816 ec.Error(ctx, err)
4817 return graphql.Null
4818 }
4819 if resTmp == nil {
4820 if !graphql.HasFieldError(ctx, fc) {
4821 ec.Errorf(ctx, "must not be null")
4822 }
4823 return graphql.Null
4824 }
4825 res := resTmp.(time.Time)
4826 fc.Result = res
4827 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
4828}
4829
4830func (ec *executionContext) fieldContext_Bug_createdAt(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4831 fc = &graphql.FieldContext{
4832 Object: "Bug",
4833 Field: field,
4834 IsMethod: true,
4835 IsResolver: false,
4836 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4837 return nil, errors.New("field of type Time does not have child fields")
4838 },
4839 }
4840 return fc, nil
4841}
4842
4843func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4844 fc, err := ec.fieldContext_Bug_lastEdit(ctx, field)
4845 if err != nil {
4846 return graphql.Null
4847 }
4848 ctx = graphql.WithFieldContext(ctx, fc)
4849 defer func() {
4850 if r := recover(); r != nil {
4851 ec.Error(ctx, ec.Recover(ctx, r))
4852 ret = graphql.Null
4853 }
4854 }()
4855 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4856 ctx = rctx // use context from middleware stack in children
4857 return obj.LastEdit(), nil
4858 })
4859 if err != nil {
4860 ec.Error(ctx, err)
4861 return graphql.Null
4862 }
4863 if resTmp == nil {
4864 if !graphql.HasFieldError(ctx, fc) {
4865 ec.Errorf(ctx, "must not be null")
4866 }
4867 return graphql.Null
4868 }
4869 res := resTmp.(time.Time)
4870 fc.Result = res
4871 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
4872}
4873
4874func (ec *executionContext) fieldContext_Bug_lastEdit(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4875 fc = &graphql.FieldContext{
4876 Object: "Bug",
4877 Field: field,
4878 IsMethod: true,
4879 IsResolver: false,
4880 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4881 return nil, errors.New("field of type Time does not have child fields")
4882 },
4883 }
4884 return fc, nil
4885}
4886
4887func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4888 fc, err := ec.fieldContext_Bug_actors(ctx, field)
4889 if err != nil {
4890 return graphql.Null
4891 }
4892 ctx = graphql.WithFieldContext(ctx, fc)
4893 defer func() {
4894 if r := recover(); r != nil {
4895 ec.Error(ctx, ec.Recover(ctx, r))
4896 ret = graphql.Null
4897 }
4898 }()
4899 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4900 ctx = rctx // use context from middleware stack in children
4901 return ec.resolvers.Bug().Actors(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
4902 })
4903 if err != nil {
4904 ec.Error(ctx, err)
4905 return graphql.Null
4906 }
4907 if resTmp == nil {
4908 if !graphql.HasFieldError(ctx, fc) {
4909 ec.Errorf(ctx, "must not be null")
4910 }
4911 return graphql.Null
4912 }
4913 res := resTmp.(*models.IdentityConnection)
4914 fc.Result = res
4915 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4916}
4917
4918func (ec *executionContext) fieldContext_Bug_actors(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4919 fc = &graphql.FieldContext{
4920 Object: "Bug",
4921 Field: field,
4922 IsMethod: true,
4923 IsResolver: true,
4924 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4925 switch field.Name {
4926 case "edges":
4927 return ec.fieldContext_IdentityConnection_edges(ctx, field)
4928 case "nodes":
4929 return ec.fieldContext_IdentityConnection_nodes(ctx, field)
4930 case "pageInfo":
4931 return ec.fieldContext_IdentityConnection_pageInfo(ctx, field)
4932 case "totalCount":
4933 return ec.fieldContext_IdentityConnection_totalCount(ctx, field)
4934 }
4935 return nil, fmt.Errorf("no field named %q was found under type IdentityConnection", field.Name)
4936 },
4937 }
4938 defer func() {
4939 if r := recover(); r != nil {
4940 err = ec.Recover(ctx, r)
4941 ec.Error(ctx, err)
4942 }
4943 }()
4944 ctx = graphql.WithFieldContext(ctx, fc)
4945 if fc.Args, err = ec.field_Bug_actors_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
4946 ec.Error(ctx, err)
4947 return
4948 }
4949 return fc, nil
4950}
4951
4952func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4953 fc, err := ec.fieldContext_Bug_participants(ctx, field)
4954 if err != nil {
4955 return graphql.Null
4956 }
4957 ctx = graphql.WithFieldContext(ctx, fc)
4958 defer func() {
4959 if r := recover(); r != nil {
4960 ec.Error(ctx, ec.Recover(ctx, r))
4961 ret = graphql.Null
4962 }
4963 }()
4964 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4965 ctx = rctx // use context from middleware stack in children
4966 return ec.resolvers.Bug().Participants(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
4967 })
4968 if err != nil {
4969 ec.Error(ctx, err)
4970 return graphql.Null
4971 }
4972 if resTmp == nil {
4973 if !graphql.HasFieldError(ctx, fc) {
4974 ec.Errorf(ctx, "must not be null")
4975 }
4976 return graphql.Null
4977 }
4978 res := resTmp.(*models.IdentityConnection)
4979 fc.Result = res
4980 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4981}
4982
4983func (ec *executionContext) fieldContext_Bug_participants(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4984 fc = &graphql.FieldContext{
4985 Object: "Bug",
4986 Field: field,
4987 IsMethod: true,
4988 IsResolver: true,
4989 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4990 switch field.Name {
4991 case "edges":
4992 return ec.fieldContext_IdentityConnection_edges(ctx, field)
4993 case "nodes":
4994 return ec.fieldContext_IdentityConnection_nodes(ctx, field)
4995 case "pageInfo":
4996 return ec.fieldContext_IdentityConnection_pageInfo(ctx, field)
4997 case "totalCount":
4998 return ec.fieldContext_IdentityConnection_totalCount(ctx, field)
4999 }
5000 return nil, fmt.Errorf("no field named %q was found under type IdentityConnection", field.Name)
5001 },
5002 }
5003 defer func() {
5004 if r := recover(); r != nil {
5005 err = ec.Recover(ctx, r)
5006 ec.Error(ctx, err)
5007 }
5008 }()
5009 ctx = graphql.WithFieldContext(ctx, fc)
5010 if fc.Args, err = ec.field_Bug_participants_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
5011 ec.Error(ctx, err)
5012 return
5013 }
5014 return fc, nil
5015}
5016
5017func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
5018 fc, err := ec.fieldContext_Bug_comments(ctx, field)
5019 if err != nil {
5020 return graphql.Null
5021 }
5022 ctx = graphql.WithFieldContext(ctx, fc)
5023 defer func() {
5024 if r := recover(); r != nil {
5025 ec.Error(ctx, ec.Recover(ctx, r))
5026 ret = graphql.Null
5027 }
5028 }()
5029 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5030 ctx = rctx // use context from middleware stack in children
5031 return ec.resolvers.Bug().Comments(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
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.(*models.CommentConnection)
5044 fc.Result = res
5045 return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
5046}
5047
5048func (ec *executionContext) fieldContext_Bug_comments(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5049 fc = &graphql.FieldContext{
5050 Object: "Bug",
5051 Field: field,
5052 IsMethod: true,
5053 IsResolver: true,
5054 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5055 switch field.Name {
5056 case "edges":
5057 return ec.fieldContext_CommentConnection_edges(ctx, field)
5058 case "nodes":
5059 return ec.fieldContext_CommentConnection_nodes(ctx, field)
5060 case "pageInfo":
5061 return ec.fieldContext_CommentConnection_pageInfo(ctx, field)
5062 case "totalCount":
5063 return ec.fieldContext_CommentConnection_totalCount(ctx, field)
5064 }
5065 return nil, fmt.Errorf("no field named %q was found under type CommentConnection", field.Name)
5066 },
5067 }
5068 defer func() {
5069 if r := recover(); r != nil {
5070 err = ec.Recover(ctx, r)
5071 ec.Error(ctx, err)
5072 }
5073 }()
5074 ctx = graphql.WithFieldContext(ctx, fc)
5075 if fc.Args, err = ec.field_Bug_comments_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
5076 ec.Error(ctx, err)
5077 return
5078 }
5079 return fc, nil
5080}
5081
5082func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
5083 fc, err := ec.fieldContext_Bug_timeline(ctx, field)
5084 if err != nil {
5085 return graphql.Null
5086 }
5087 ctx = graphql.WithFieldContext(ctx, fc)
5088 defer func() {
5089 if r := recover(); r != nil {
5090 ec.Error(ctx, ec.Recover(ctx, r))
5091 ret = graphql.Null
5092 }
5093 }()
5094 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5095 ctx = rctx // use context from middleware stack in children
5096 return ec.resolvers.Bug().Timeline(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
5097 })
5098 if err != nil {
5099 ec.Error(ctx, err)
5100 return graphql.Null
5101 }
5102 if resTmp == nil {
5103 if !graphql.HasFieldError(ctx, fc) {
5104 ec.Errorf(ctx, "must not be null")
5105 }
5106 return graphql.Null
5107 }
5108 res := resTmp.(*models.TimelineItemConnection)
5109 fc.Result = res
5110 return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
5111}
5112
5113func (ec *executionContext) fieldContext_Bug_timeline(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5114 fc = &graphql.FieldContext{
5115 Object: "Bug",
5116 Field: field,
5117 IsMethod: true,
5118 IsResolver: true,
5119 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5120 switch field.Name {
5121 case "edges":
5122 return ec.fieldContext_TimelineItemConnection_edges(ctx, field)
5123 case "nodes":
5124 return ec.fieldContext_TimelineItemConnection_nodes(ctx, field)
5125 case "pageInfo":
5126 return ec.fieldContext_TimelineItemConnection_pageInfo(ctx, field)
5127 case "totalCount":
5128 return ec.fieldContext_TimelineItemConnection_totalCount(ctx, field)
5129 }
5130 return nil, fmt.Errorf("no field named %q was found under type TimelineItemConnection", field.Name)
5131 },
5132 }
5133 defer func() {
5134 if r := recover(); r != nil {
5135 err = ec.Recover(ctx, r)
5136 ec.Error(ctx, err)
5137 }
5138 }()
5139 ctx = graphql.WithFieldContext(ctx, fc)
5140 if fc.Args, err = ec.field_Bug_timeline_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
5141 ec.Error(ctx, err)
5142 return
5143 }
5144 return fc, nil
5145}
5146
5147func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
5148 fc, err := ec.fieldContext_Bug_operations(ctx, field)
5149 if err != nil {
5150 return graphql.Null
5151 }
5152 ctx = graphql.WithFieldContext(ctx, fc)
5153 defer func() {
5154 if r := recover(); r != nil {
5155 ec.Error(ctx, ec.Recover(ctx, r))
5156 ret = graphql.Null
5157 }
5158 }()
5159 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5160 ctx = rctx // use context from middleware stack in children
5161 return ec.resolvers.Bug().Operations(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
5162 })
5163 if err != nil {
5164 ec.Error(ctx, err)
5165 return graphql.Null
5166 }
5167 if resTmp == nil {
5168 if !graphql.HasFieldError(ctx, fc) {
5169 ec.Errorf(ctx, "must not be null")
5170 }
5171 return graphql.Null
5172 }
5173 res := resTmp.(*models.OperationConnection)
5174 fc.Result = res
5175 return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
5176}
5177
5178func (ec *executionContext) fieldContext_Bug_operations(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5179 fc = &graphql.FieldContext{
5180 Object: "Bug",
5181 Field: field,
5182 IsMethod: true,
5183 IsResolver: true,
5184 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5185 switch field.Name {
5186 case "edges":
5187 return ec.fieldContext_OperationConnection_edges(ctx, field)
5188 case "nodes":
5189 return ec.fieldContext_OperationConnection_nodes(ctx, field)
5190 case "pageInfo":
5191 return ec.fieldContext_OperationConnection_pageInfo(ctx, field)
5192 case "totalCount":
5193 return ec.fieldContext_OperationConnection_totalCount(ctx, field)
5194 }
5195 return nil, fmt.Errorf("no field named %q was found under type OperationConnection", field.Name)
5196 },
5197 }
5198 defer func() {
5199 if r := recover(); r != nil {
5200 err = ec.Recover(ctx, r)
5201 ec.Error(ctx, err)
5202 }
5203 }()
5204 ctx = graphql.WithFieldContext(ctx, fc)
5205 if fc.Args, err = ec.field_Bug_operations_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
5206 ec.Error(ctx, err)
5207 return
5208 }
5209 return fc, nil
5210}
5211
5212func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
5213 fc, err := ec.fieldContext_BugConnection_edges(ctx, field)
5214 if err != nil {
5215 return graphql.Null
5216 }
5217 ctx = graphql.WithFieldContext(ctx, fc)
5218 defer func() {
5219 if r := recover(); r != nil {
5220 ec.Error(ctx, ec.Recover(ctx, r))
5221 ret = graphql.Null
5222 }
5223 }()
5224 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5225 ctx = rctx // use context from middleware stack in children
5226 return obj.Edges, nil
5227 })
5228 if err != nil {
5229 ec.Error(ctx, err)
5230 return graphql.Null
5231 }
5232 if resTmp == nil {
5233 if !graphql.HasFieldError(ctx, fc) {
5234 ec.Errorf(ctx, "must not be null")
5235 }
5236 return graphql.Null
5237 }
5238 res := resTmp.([]*models.BugEdge)
5239 fc.Result = res
5240 return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
5241}
5242
5243func (ec *executionContext) fieldContext_BugConnection_edges(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5244 fc = &graphql.FieldContext{
5245 Object: "BugConnection",
5246 Field: field,
5247 IsMethod: false,
5248 IsResolver: false,
5249 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5250 switch field.Name {
5251 case "cursor":
5252 return ec.fieldContext_BugEdge_cursor(ctx, field)
5253 case "node":
5254 return ec.fieldContext_BugEdge_node(ctx, field)
5255 }
5256 return nil, fmt.Errorf("no field named %q was found under type BugEdge", field.Name)
5257 },
5258 }
5259 return fc, nil
5260}
5261
5262func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
5263 fc, err := ec.fieldContext_BugConnection_nodes(ctx, field)
5264 if err != nil {
5265 return graphql.Null
5266 }
5267 ctx = graphql.WithFieldContext(ctx, fc)
5268 defer func() {
5269 if r := recover(); r != nil {
5270 ec.Error(ctx, ec.Recover(ctx, r))
5271 ret = graphql.Null
5272 }
5273 }()
5274 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5275 ctx = rctx // use context from middleware stack in children
5276 return obj.Nodes, nil
5277 })
5278 if err != nil {
5279 ec.Error(ctx, err)
5280 return graphql.Null
5281 }
5282 if resTmp == nil {
5283 if !graphql.HasFieldError(ctx, fc) {
5284 ec.Errorf(ctx, "must not be null")
5285 }
5286 return graphql.Null
5287 }
5288 res := resTmp.([]models.BugWrapper)
5289 fc.Result = res
5290 return ec.marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx, field.Selections, res)
5291}
5292
5293func (ec *executionContext) fieldContext_BugConnection_nodes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5294 fc = &graphql.FieldContext{
5295 Object: "BugConnection",
5296 Field: field,
5297 IsMethod: false,
5298 IsResolver: false,
5299 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5300 switch field.Name {
5301 case "id":
5302 return ec.fieldContext_Bug_id(ctx, field)
5303 case "humanId":
5304 return ec.fieldContext_Bug_humanId(ctx, field)
5305 case "status":
5306 return ec.fieldContext_Bug_status(ctx, field)
5307 case "title":
5308 return ec.fieldContext_Bug_title(ctx, field)
5309 case "labels":
5310 return ec.fieldContext_Bug_labels(ctx, field)
5311 case "author":
5312 return ec.fieldContext_Bug_author(ctx, field)
5313 case "createdAt":
5314 return ec.fieldContext_Bug_createdAt(ctx, field)
5315 case "lastEdit":
5316 return ec.fieldContext_Bug_lastEdit(ctx, field)
5317 case "actors":
5318 return ec.fieldContext_Bug_actors(ctx, field)
5319 case "participants":
5320 return ec.fieldContext_Bug_participants(ctx, field)
5321 case "comments":
5322 return ec.fieldContext_Bug_comments(ctx, field)
5323 case "timeline":
5324 return ec.fieldContext_Bug_timeline(ctx, field)
5325 case "operations":
5326 return ec.fieldContext_Bug_operations(ctx, field)
5327 }
5328 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
5329 },
5330 }
5331 return fc, nil
5332}
5333
5334func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
5335 fc, err := ec.fieldContext_BugConnection_pageInfo(ctx, field)
5336 if err != nil {
5337 return graphql.Null
5338 }
5339 ctx = graphql.WithFieldContext(ctx, fc)
5340 defer func() {
5341 if r := recover(); r != nil {
5342 ec.Error(ctx, ec.Recover(ctx, r))
5343 ret = graphql.Null
5344 }
5345 }()
5346 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5347 ctx = rctx // use context from middleware stack in children
5348 return obj.PageInfo, nil
5349 })
5350 if err != nil {
5351 ec.Error(ctx, err)
5352 return graphql.Null
5353 }
5354 if resTmp == nil {
5355 if !graphql.HasFieldError(ctx, fc) {
5356 ec.Errorf(ctx, "must not be null")
5357 }
5358 return graphql.Null
5359 }
5360 res := resTmp.(*models.PageInfo)
5361 fc.Result = res
5362 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
5363}
5364
5365func (ec *executionContext) fieldContext_BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5366 fc = &graphql.FieldContext{
5367 Object: "BugConnection",
5368 Field: field,
5369 IsMethod: false,
5370 IsResolver: false,
5371 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5372 switch field.Name {
5373 case "hasNextPage":
5374 return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
5375 case "hasPreviousPage":
5376 return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
5377 case "startCursor":
5378 return ec.fieldContext_PageInfo_startCursor(ctx, field)
5379 case "endCursor":
5380 return ec.fieldContext_PageInfo_endCursor(ctx, field)
5381 }
5382 return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
5383 },
5384 }
5385 return fc, nil
5386}
5387
5388func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
5389 fc, err := ec.fieldContext_BugConnection_totalCount(ctx, field)
5390 if err != nil {
5391 return graphql.Null
5392 }
5393 ctx = graphql.WithFieldContext(ctx, fc)
5394 defer func() {
5395 if r := recover(); r != nil {
5396 ec.Error(ctx, ec.Recover(ctx, r))
5397 ret = graphql.Null
5398 }
5399 }()
5400 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5401 ctx = rctx // use context from middleware stack in children
5402 return obj.TotalCount, nil
5403 })
5404 if err != nil {
5405 ec.Error(ctx, err)
5406 return graphql.Null
5407 }
5408 if resTmp == nil {
5409 if !graphql.HasFieldError(ctx, fc) {
5410 ec.Errorf(ctx, "must not be null")
5411 }
5412 return graphql.Null
5413 }
5414 res := resTmp.(int)
5415 fc.Result = res
5416 return ec.marshalNInt2int(ctx, field.Selections, res)
5417}
5418
5419func (ec *executionContext) fieldContext_BugConnection_totalCount(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5420 fc = &graphql.FieldContext{
5421 Object: "BugConnection",
5422 Field: field,
5423 IsMethod: false,
5424 IsResolver: false,
5425 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5426 return nil, errors.New("field of type Int does not have child fields")
5427 },
5428 }
5429 return fc, nil
5430}
5431
5432func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
5433 fc, err := ec.fieldContext_BugEdge_cursor(ctx, field)
5434 if err != nil {
5435 return graphql.Null
5436 }
5437 ctx = graphql.WithFieldContext(ctx, fc)
5438 defer func() {
5439 if r := recover(); r != nil {
5440 ec.Error(ctx, ec.Recover(ctx, r))
5441 ret = graphql.Null
5442 }
5443 }()
5444 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5445 ctx = rctx // use context from middleware stack in children
5446 return obj.Cursor, nil
5447 })
5448 if err != nil {
5449 ec.Error(ctx, err)
5450 return graphql.Null
5451 }
5452 if resTmp == nil {
5453 if !graphql.HasFieldError(ctx, fc) {
5454 ec.Errorf(ctx, "must not be null")
5455 }
5456 return graphql.Null
5457 }
5458 res := resTmp.(string)
5459 fc.Result = res
5460 return ec.marshalNString2string(ctx, field.Selections, res)
5461}
5462
5463func (ec *executionContext) fieldContext_BugEdge_cursor(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5464 fc = &graphql.FieldContext{
5465 Object: "BugEdge",
5466 Field: field,
5467 IsMethod: false,
5468 IsResolver: false,
5469 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5470 return nil, errors.New("field of type String does not have child fields")
5471 },
5472 }
5473 return fc, nil
5474}
5475
5476func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
5477 fc, err := ec.fieldContext_BugEdge_node(ctx, field)
5478 if err != nil {
5479 return graphql.Null
5480 }
5481 ctx = graphql.WithFieldContext(ctx, fc)
5482 defer func() {
5483 if r := recover(); r != nil {
5484 ec.Error(ctx, ec.Recover(ctx, r))
5485 ret = graphql.Null
5486 }
5487 }()
5488 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5489 ctx = rctx // use context from middleware stack in children
5490 return obj.Node, nil
5491 })
5492 if err != nil {
5493 ec.Error(ctx, err)
5494 return graphql.Null
5495 }
5496 if resTmp == nil {
5497 if !graphql.HasFieldError(ctx, fc) {
5498 ec.Errorf(ctx, "must not be null")
5499 }
5500 return graphql.Null
5501 }
5502 res := resTmp.(models.BugWrapper)
5503 fc.Result = res
5504 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
5505}
5506
5507func (ec *executionContext) fieldContext_BugEdge_node(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5508 fc = &graphql.FieldContext{
5509 Object: "BugEdge",
5510 Field: field,
5511 IsMethod: false,
5512 IsResolver: false,
5513 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5514 switch field.Name {
5515 case "id":
5516 return ec.fieldContext_Bug_id(ctx, field)
5517 case "humanId":
5518 return ec.fieldContext_Bug_humanId(ctx, field)
5519 case "status":
5520 return ec.fieldContext_Bug_status(ctx, field)
5521 case "title":
5522 return ec.fieldContext_Bug_title(ctx, field)
5523 case "labels":
5524 return ec.fieldContext_Bug_labels(ctx, field)
5525 case "author":
5526 return ec.fieldContext_Bug_author(ctx, field)
5527 case "createdAt":
5528 return ec.fieldContext_Bug_createdAt(ctx, field)
5529 case "lastEdit":
5530 return ec.fieldContext_Bug_lastEdit(ctx, field)
5531 case "actors":
5532 return ec.fieldContext_Bug_actors(ctx, field)
5533 case "participants":
5534 return ec.fieldContext_Bug_participants(ctx, field)
5535 case "comments":
5536 return ec.fieldContext_Bug_comments(ctx, field)
5537 case "timeline":
5538 return ec.fieldContext_Bug_timeline(ctx, field)
5539 case "operations":
5540 return ec.fieldContext_Bug_operations(ctx, field)
5541 }
5542 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
5543 },
5544 }
5545 return fc, nil
5546}
5547
5548func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
5549 fc, err := ec.fieldContext_ChangeLabelPayload_clientMutationId(ctx, field)
5550 if err != nil {
5551 return graphql.Null
5552 }
5553 ctx = graphql.WithFieldContext(ctx, fc)
5554 defer func() {
5555 if r := recover(); r != nil {
5556 ec.Error(ctx, ec.Recover(ctx, r))
5557 ret = graphql.Null
5558 }
5559 }()
5560 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5561 ctx = rctx // use context from middleware stack in children
5562 return obj.ClientMutationID, nil
5563 })
5564 if err != nil {
5565 ec.Error(ctx, err)
5566 return graphql.Null
5567 }
5568 if resTmp == nil {
5569 return graphql.Null
5570 }
5571 res := resTmp.(*string)
5572 fc.Result = res
5573 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
5574}
5575
5576func (ec *executionContext) fieldContext_ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5577 fc = &graphql.FieldContext{
5578 Object: "ChangeLabelPayload",
5579 Field: field,
5580 IsMethod: false,
5581 IsResolver: false,
5582 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5583 return nil, errors.New("field of type String does not have child fields")
5584 },
5585 }
5586 return fc, nil
5587}
5588
5589func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
5590 fc, err := ec.fieldContext_ChangeLabelPayload_bug(ctx, field)
5591 if err != nil {
5592 return graphql.Null
5593 }
5594 ctx = graphql.WithFieldContext(ctx, fc)
5595 defer func() {
5596 if r := recover(); r != nil {
5597 ec.Error(ctx, ec.Recover(ctx, r))
5598 ret = graphql.Null
5599 }
5600 }()
5601 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5602 ctx = rctx // use context from middleware stack in children
5603 return obj.Bug, nil
5604 })
5605 if err != nil {
5606 ec.Error(ctx, err)
5607 return graphql.Null
5608 }
5609 if resTmp == nil {
5610 if !graphql.HasFieldError(ctx, fc) {
5611 ec.Errorf(ctx, "must not be null")
5612 }
5613 return graphql.Null
5614 }
5615 res := resTmp.(models.BugWrapper)
5616 fc.Result = res
5617 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
5618}
5619
5620func (ec *executionContext) fieldContext_ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5621 fc = &graphql.FieldContext{
5622 Object: "ChangeLabelPayload",
5623 Field: field,
5624 IsMethod: false,
5625 IsResolver: false,
5626 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5627 switch field.Name {
5628 case "id":
5629 return ec.fieldContext_Bug_id(ctx, field)
5630 case "humanId":
5631 return ec.fieldContext_Bug_humanId(ctx, field)
5632 case "status":
5633 return ec.fieldContext_Bug_status(ctx, field)
5634 case "title":
5635 return ec.fieldContext_Bug_title(ctx, field)
5636 case "labels":
5637 return ec.fieldContext_Bug_labels(ctx, field)
5638 case "author":
5639 return ec.fieldContext_Bug_author(ctx, field)
5640 case "createdAt":
5641 return ec.fieldContext_Bug_createdAt(ctx, field)
5642 case "lastEdit":
5643 return ec.fieldContext_Bug_lastEdit(ctx, field)
5644 case "actors":
5645 return ec.fieldContext_Bug_actors(ctx, field)
5646 case "participants":
5647 return ec.fieldContext_Bug_participants(ctx, field)
5648 case "comments":
5649 return ec.fieldContext_Bug_comments(ctx, field)
5650 case "timeline":
5651 return ec.fieldContext_Bug_timeline(ctx, field)
5652 case "operations":
5653 return ec.fieldContext_Bug_operations(ctx, field)
5654 }
5655 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
5656 },
5657 }
5658 return fc, nil
5659}
5660
5661func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
5662 fc, err := ec.fieldContext_ChangeLabelPayload_operation(ctx, field)
5663 if err != nil {
5664 return graphql.Null
5665 }
5666 ctx = graphql.WithFieldContext(ctx, fc)
5667 defer func() {
5668 if r := recover(); r != nil {
5669 ec.Error(ctx, ec.Recover(ctx, r))
5670 ret = graphql.Null
5671 }
5672 }()
5673 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5674 ctx = rctx // use context from middleware stack in children
5675 return obj.Operation, nil
5676 })
5677 if err != nil {
5678 ec.Error(ctx, err)
5679 return graphql.Null
5680 }
5681 if resTmp == nil {
5682 if !graphql.HasFieldError(ctx, fc) {
5683 ec.Errorf(ctx, "must not be null")
5684 }
5685 return graphql.Null
5686 }
5687 res := resTmp.(*bug.LabelChangeOperation)
5688 fc.Result = res
5689 return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
5690}
5691
5692func (ec *executionContext) fieldContext_ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5693 fc = &graphql.FieldContext{
5694 Object: "ChangeLabelPayload",
5695 Field: field,
5696 IsMethod: false,
5697 IsResolver: false,
5698 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5699 switch field.Name {
5700 case "id":
5701 return ec.fieldContext_LabelChangeOperation_id(ctx, field)
5702 case "author":
5703 return ec.fieldContext_LabelChangeOperation_author(ctx, field)
5704 case "date":
5705 return ec.fieldContext_LabelChangeOperation_date(ctx, field)
5706 case "added":
5707 return ec.fieldContext_LabelChangeOperation_added(ctx, field)
5708 case "removed":
5709 return ec.fieldContext_LabelChangeOperation_removed(ctx, field)
5710 }
5711 return nil, fmt.Errorf("no field named %q was found under type LabelChangeOperation", field.Name)
5712 },
5713 }
5714 return fc, nil
5715}
5716
5717func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
5718 fc, err := ec.fieldContext_ChangeLabelPayload_results(ctx, field)
5719 if err != nil {
5720 return graphql.Null
5721 }
5722 ctx = graphql.WithFieldContext(ctx, fc)
5723 defer func() {
5724 if r := recover(); r != nil {
5725 ec.Error(ctx, ec.Recover(ctx, r))
5726 ret = graphql.Null
5727 }
5728 }()
5729 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5730 ctx = rctx // use context from middleware stack in children
5731 return obj.Results, nil
5732 })
5733 if err != nil {
5734 ec.Error(ctx, err)
5735 return graphql.Null
5736 }
5737 if resTmp == nil {
5738 if !graphql.HasFieldError(ctx, fc) {
5739 ec.Errorf(ctx, "must not be null")
5740 }
5741 return graphql.Null
5742 }
5743 res := resTmp.([]*bug.LabelChangeResult)
5744 fc.Result = res
5745 return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
5746}
5747
5748func (ec *executionContext) fieldContext_ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5749 fc = &graphql.FieldContext{
5750 Object: "ChangeLabelPayload",
5751 Field: field,
5752 IsMethod: false,
5753 IsResolver: false,
5754 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5755 switch field.Name {
5756 case "label":
5757 return ec.fieldContext_LabelChangeResult_label(ctx, field)
5758 case "status":
5759 return ec.fieldContext_LabelChangeResult_status(ctx, field)
5760 }
5761 return nil, fmt.Errorf("no field named %q was found under type LabelChangeResult", field.Name)
5762 },
5763 }
5764 return fc, nil
5765}
5766
5767func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
5768 fc, err := ec.fieldContext_CloseBugPayload_clientMutationId(ctx, field)
5769 if err != nil {
5770 return graphql.Null
5771 }
5772 ctx = graphql.WithFieldContext(ctx, fc)
5773 defer func() {
5774 if r := recover(); r != nil {
5775 ec.Error(ctx, ec.Recover(ctx, r))
5776 ret = graphql.Null
5777 }
5778 }()
5779 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5780 ctx = rctx // use context from middleware stack in children
5781 return obj.ClientMutationID, nil
5782 })
5783 if err != nil {
5784 ec.Error(ctx, err)
5785 return graphql.Null
5786 }
5787 if resTmp == nil {
5788 return graphql.Null
5789 }
5790 res := resTmp.(*string)
5791 fc.Result = res
5792 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
5793}
5794
5795func (ec *executionContext) fieldContext_CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5796 fc = &graphql.FieldContext{
5797 Object: "CloseBugPayload",
5798 Field: field,
5799 IsMethod: false,
5800 IsResolver: false,
5801 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5802 return nil, errors.New("field of type String does not have child fields")
5803 },
5804 }
5805 return fc, nil
5806}
5807
5808func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
5809 fc, err := ec.fieldContext_CloseBugPayload_bug(ctx, field)
5810 if err != nil {
5811 return graphql.Null
5812 }
5813 ctx = graphql.WithFieldContext(ctx, fc)
5814 defer func() {
5815 if r := recover(); r != nil {
5816 ec.Error(ctx, ec.Recover(ctx, r))
5817 ret = graphql.Null
5818 }
5819 }()
5820 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5821 ctx = rctx // use context from middleware stack in children
5822 return obj.Bug, nil
5823 })
5824 if err != nil {
5825 ec.Error(ctx, err)
5826 return graphql.Null
5827 }
5828 if resTmp == nil {
5829 if !graphql.HasFieldError(ctx, fc) {
5830 ec.Errorf(ctx, "must not be null")
5831 }
5832 return graphql.Null
5833 }
5834 res := resTmp.(models.BugWrapper)
5835 fc.Result = res
5836 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
5837}
5838
5839func (ec *executionContext) fieldContext_CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5840 fc = &graphql.FieldContext{
5841 Object: "CloseBugPayload",
5842 Field: field,
5843 IsMethod: false,
5844 IsResolver: false,
5845 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5846 switch field.Name {
5847 case "id":
5848 return ec.fieldContext_Bug_id(ctx, field)
5849 case "humanId":
5850 return ec.fieldContext_Bug_humanId(ctx, field)
5851 case "status":
5852 return ec.fieldContext_Bug_status(ctx, field)
5853 case "title":
5854 return ec.fieldContext_Bug_title(ctx, field)
5855 case "labels":
5856 return ec.fieldContext_Bug_labels(ctx, field)
5857 case "author":
5858 return ec.fieldContext_Bug_author(ctx, field)
5859 case "createdAt":
5860 return ec.fieldContext_Bug_createdAt(ctx, field)
5861 case "lastEdit":
5862 return ec.fieldContext_Bug_lastEdit(ctx, field)
5863 case "actors":
5864 return ec.fieldContext_Bug_actors(ctx, field)
5865 case "participants":
5866 return ec.fieldContext_Bug_participants(ctx, field)
5867 case "comments":
5868 return ec.fieldContext_Bug_comments(ctx, field)
5869 case "timeline":
5870 return ec.fieldContext_Bug_timeline(ctx, field)
5871 case "operations":
5872 return ec.fieldContext_Bug_operations(ctx, field)
5873 }
5874 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
5875 },
5876 }
5877 return fc, nil
5878}
5879
5880func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
5881 fc, err := ec.fieldContext_CloseBugPayload_operation(ctx, field)
5882 if err != nil {
5883 return graphql.Null
5884 }
5885 ctx = graphql.WithFieldContext(ctx, fc)
5886 defer func() {
5887 if r := recover(); r != nil {
5888 ec.Error(ctx, ec.Recover(ctx, r))
5889 ret = graphql.Null
5890 }
5891 }()
5892 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5893 ctx = rctx // use context from middleware stack in children
5894 return obj.Operation, nil
5895 })
5896 if err != nil {
5897 ec.Error(ctx, err)
5898 return graphql.Null
5899 }
5900 if resTmp == nil {
5901 if !graphql.HasFieldError(ctx, fc) {
5902 ec.Errorf(ctx, "must not be null")
5903 }
5904 return graphql.Null
5905 }
5906 res := resTmp.(*bug.SetStatusOperation)
5907 fc.Result = res
5908 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
5909}
5910
5911func (ec *executionContext) fieldContext_CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5912 fc = &graphql.FieldContext{
5913 Object: "CloseBugPayload",
5914 Field: field,
5915 IsMethod: false,
5916 IsResolver: false,
5917 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5918 switch field.Name {
5919 case "id":
5920 return ec.fieldContext_SetStatusOperation_id(ctx, field)
5921 case "author":
5922 return ec.fieldContext_SetStatusOperation_author(ctx, field)
5923 case "date":
5924 return ec.fieldContext_SetStatusOperation_date(ctx, field)
5925 case "status":
5926 return ec.fieldContext_SetStatusOperation_status(ctx, field)
5927 }
5928 return nil, fmt.Errorf("no field named %q was found under type SetStatusOperation", field.Name)
5929 },
5930 }
5931 return fc, nil
5932}
5933
5934func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
5935 fc, err := ec.fieldContext_Color_R(ctx, field)
5936 if err != nil {
5937 return graphql.Null
5938 }
5939 ctx = graphql.WithFieldContext(ctx, fc)
5940 defer func() {
5941 if r := recover(); r != nil {
5942 ec.Error(ctx, ec.Recover(ctx, r))
5943 ret = graphql.Null
5944 }
5945 }()
5946 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5947 ctx = rctx // use context from middleware stack in children
5948 return ec.resolvers.Color().R(rctx, obj)
5949 })
5950 if err != nil {
5951 ec.Error(ctx, err)
5952 return graphql.Null
5953 }
5954 if resTmp == nil {
5955 if !graphql.HasFieldError(ctx, fc) {
5956 ec.Errorf(ctx, "must not be null")
5957 }
5958 return graphql.Null
5959 }
5960 res := resTmp.(int)
5961 fc.Result = res
5962 return ec.marshalNInt2int(ctx, field.Selections, res)
5963}
5964
5965func (ec *executionContext) fieldContext_Color_R(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5966 fc = &graphql.FieldContext{
5967 Object: "Color",
5968 Field: field,
5969 IsMethod: true,
5970 IsResolver: true,
5971 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5972 return nil, errors.New("field of type Int does not have child fields")
5973 },
5974 }
5975 return fc, nil
5976}
5977
5978func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
5979 fc, err := ec.fieldContext_Color_G(ctx, field)
5980 if err != nil {
5981 return graphql.Null
5982 }
5983 ctx = graphql.WithFieldContext(ctx, fc)
5984 defer func() {
5985 if r := recover(); r != nil {
5986 ec.Error(ctx, ec.Recover(ctx, r))
5987 ret = graphql.Null
5988 }
5989 }()
5990 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5991 ctx = rctx // use context from middleware stack in children
5992 return ec.resolvers.Color().G(rctx, obj)
5993 })
5994 if err != nil {
5995 ec.Error(ctx, err)
5996 return graphql.Null
5997 }
5998 if resTmp == nil {
5999 if !graphql.HasFieldError(ctx, fc) {
6000 ec.Errorf(ctx, "must not be null")
6001 }
6002 return graphql.Null
6003 }
6004 res := resTmp.(int)
6005 fc.Result = res
6006 return ec.marshalNInt2int(ctx, field.Selections, res)
6007}
6008
6009func (ec *executionContext) fieldContext_Color_G(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6010 fc = &graphql.FieldContext{
6011 Object: "Color",
6012 Field: field,
6013 IsMethod: true,
6014 IsResolver: true,
6015 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6016 return nil, errors.New("field of type Int does not have child fields")
6017 },
6018 }
6019 return fc, nil
6020}
6021
6022func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
6023 fc, err := ec.fieldContext_Color_B(ctx, field)
6024 if err != nil {
6025 return graphql.Null
6026 }
6027 ctx = graphql.WithFieldContext(ctx, fc)
6028 defer func() {
6029 if r := recover(); r != nil {
6030 ec.Error(ctx, ec.Recover(ctx, r))
6031 ret = graphql.Null
6032 }
6033 }()
6034 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6035 ctx = rctx // use context from middleware stack in children
6036 return ec.resolvers.Color().B(rctx, obj)
6037 })
6038 if err != nil {
6039 ec.Error(ctx, err)
6040 return graphql.Null
6041 }
6042 if resTmp == nil {
6043 if !graphql.HasFieldError(ctx, fc) {
6044 ec.Errorf(ctx, "must not be null")
6045 }
6046 return graphql.Null
6047 }
6048 res := resTmp.(int)
6049 fc.Result = res
6050 return ec.marshalNInt2int(ctx, field.Selections, res)
6051}
6052
6053func (ec *executionContext) fieldContext_Color_B(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6054 fc = &graphql.FieldContext{
6055 Object: "Color",
6056 Field: field,
6057 IsMethod: true,
6058 IsResolver: true,
6059 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6060 return nil, errors.New("field of type Int does not have child fields")
6061 },
6062 }
6063 return fc, nil
6064}
6065
6066func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
6067 fc, err := ec.fieldContext_Comment_author(ctx, field)
6068 if err != nil {
6069 return graphql.Null
6070 }
6071 ctx = graphql.WithFieldContext(ctx, fc)
6072 defer func() {
6073 if r := recover(); r != nil {
6074 ec.Error(ctx, ec.Recover(ctx, r))
6075 ret = graphql.Null
6076 }
6077 }()
6078 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6079 ctx = rctx // use context from middleware stack in children
6080 return ec.resolvers.Comment().Author(rctx, obj)
6081 })
6082 if err != nil {
6083 ec.Error(ctx, err)
6084 return graphql.Null
6085 }
6086 if resTmp == nil {
6087 if !graphql.HasFieldError(ctx, fc) {
6088 ec.Errorf(ctx, "must not be null")
6089 }
6090 return graphql.Null
6091 }
6092 res := resTmp.(models.IdentityWrapper)
6093 fc.Result = res
6094 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6095}
6096
6097func (ec *executionContext) fieldContext_Comment_author(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6098 fc = &graphql.FieldContext{
6099 Object: "Comment",
6100 Field: field,
6101 IsMethod: true,
6102 IsResolver: true,
6103 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6104 switch field.Name {
6105 case "id":
6106 return ec.fieldContext_Identity_id(ctx, field)
6107 case "humanId":
6108 return ec.fieldContext_Identity_humanId(ctx, field)
6109 case "name":
6110 return ec.fieldContext_Identity_name(ctx, field)
6111 case "email":
6112 return ec.fieldContext_Identity_email(ctx, field)
6113 case "login":
6114 return ec.fieldContext_Identity_login(ctx, field)
6115 case "displayName":
6116 return ec.fieldContext_Identity_displayName(ctx, field)
6117 case "avatarUrl":
6118 return ec.fieldContext_Identity_avatarUrl(ctx, field)
6119 case "isProtected":
6120 return ec.fieldContext_Identity_isProtected(ctx, field)
6121 }
6122 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
6123 },
6124 }
6125 return fc, nil
6126}
6127
6128func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
6129 fc, err := ec.fieldContext_Comment_message(ctx, field)
6130 if err != nil {
6131 return graphql.Null
6132 }
6133 ctx = graphql.WithFieldContext(ctx, fc)
6134 defer func() {
6135 if r := recover(); r != nil {
6136 ec.Error(ctx, ec.Recover(ctx, r))
6137 ret = graphql.Null
6138 }
6139 }()
6140 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6141 ctx = rctx // use context from middleware stack in children
6142 return obj.Message, nil
6143 })
6144 if err != nil {
6145 ec.Error(ctx, err)
6146 return graphql.Null
6147 }
6148 if resTmp == nil {
6149 if !graphql.HasFieldError(ctx, fc) {
6150 ec.Errorf(ctx, "must not be null")
6151 }
6152 return graphql.Null
6153 }
6154 res := resTmp.(string)
6155 fc.Result = res
6156 return ec.marshalNString2string(ctx, field.Selections, res)
6157}
6158
6159func (ec *executionContext) fieldContext_Comment_message(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6160 fc = &graphql.FieldContext{
6161 Object: "Comment",
6162 Field: field,
6163 IsMethod: false,
6164 IsResolver: false,
6165 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6166 return nil, errors.New("field of type String does not have child fields")
6167 },
6168 }
6169 return fc, nil
6170}
6171
6172func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
6173 fc, err := ec.fieldContext_Comment_files(ctx, field)
6174 if err != nil {
6175 return graphql.Null
6176 }
6177 ctx = graphql.WithFieldContext(ctx, fc)
6178 defer func() {
6179 if r := recover(); r != nil {
6180 ec.Error(ctx, ec.Recover(ctx, r))
6181 ret = graphql.Null
6182 }
6183 }()
6184 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6185 ctx = rctx // use context from middleware stack in children
6186 return obj.Files, nil
6187 })
6188 if err != nil {
6189 ec.Error(ctx, err)
6190 return graphql.Null
6191 }
6192 if resTmp == nil {
6193 if !graphql.HasFieldError(ctx, fc) {
6194 ec.Errorf(ctx, "must not be null")
6195 }
6196 return graphql.Null
6197 }
6198 res := resTmp.([]repository.Hash)
6199 fc.Result = res
6200 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
6201}
6202
6203func (ec *executionContext) fieldContext_Comment_files(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6204 fc = &graphql.FieldContext{
6205 Object: "Comment",
6206 Field: field,
6207 IsMethod: false,
6208 IsResolver: false,
6209 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6210 return nil, errors.New("field of type Hash does not have child fields")
6211 },
6212 }
6213 return fc, nil
6214}
6215
6216func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
6217 fc, err := ec.fieldContext_CommentConnection_edges(ctx, field)
6218 if err != nil {
6219 return graphql.Null
6220 }
6221 ctx = graphql.WithFieldContext(ctx, fc)
6222 defer func() {
6223 if r := recover(); r != nil {
6224 ec.Error(ctx, ec.Recover(ctx, r))
6225 ret = graphql.Null
6226 }
6227 }()
6228 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6229 ctx = rctx // use context from middleware stack in children
6230 return obj.Edges, nil
6231 })
6232 if err != nil {
6233 ec.Error(ctx, err)
6234 return graphql.Null
6235 }
6236 if resTmp == nil {
6237 if !graphql.HasFieldError(ctx, fc) {
6238 ec.Errorf(ctx, "must not be null")
6239 }
6240 return graphql.Null
6241 }
6242 res := resTmp.([]*models.CommentEdge)
6243 fc.Result = res
6244 return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
6245}
6246
6247func (ec *executionContext) fieldContext_CommentConnection_edges(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6248 fc = &graphql.FieldContext{
6249 Object: "CommentConnection",
6250 Field: field,
6251 IsMethod: false,
6252 IsResolver: false,
6253 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6254 switch field.Name {
6255 case "cursor":
6256 return ec.fieldContext_CommentEdge_cursor(ctx, field)
6257 case "node":
6258 return ec.fieldContext_CommentEdge_node(ctx, field)
6259 }
6260 return nil, fmt.Errorf("no field named %q was found under type CommentEdge", field.Name)
6261 },
6262 }
6263 return fc, nil
6264}
6265
6266func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
6267 fc, err := ec.fieldContext_CommentConnection_nodes(ctx, field)
6268 if err != nil {
6269 return graphql.Null
6270 }
6271 ctx = graphql.WithFieldContext(ctx, fc)
6272 defer func() {
6273 if r := recover(); r != nil {
6274 ec.Error(ctx, ec.Recover(ctx, r))
6275 ret = graphql.Null
6276 }
6277 }()
6278 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6279 ctx = rctx // use context from middleware stack in children
6280 return obj.Nodes, nil
6281 })
6282 if err != nil {
6283 ec.Error(ctx, err)
6284 return graphql.Null
6285 }
6286 if resTmp == nil {
6287 if !graphql.HasFieldError(ctx, fc) {
6288 ec.Errorf(ctx, "must not be null")
6289 }
6290 return graphql.Null
6291 }
6292 res := resTmp.([]*bug.Comment)
6293 fc.Result = res
6294 return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx, field.Selections, res)
6295}
6296
6297func (ec *executionContext) fieldContext_CommentConnection_nodes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6298 fc = &graphql.FieldContext{
6299 Object: "CommentConnection",
6300 Field: field,
6301 IsMethod: false,
6302 IsResolver: false,
6303 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6304 switch field.Name {
6305 case "author":
6306 return ec.fieldContext_Comment_author(ctx, field)
6307 case "message":
6308 return ec.fieldContext_Comment_message(ctx, field)
6309 case "files":
6310 return ec.fieldContext_Comment_files(ctx, field)
6311 }
6312 return nil, fmt.Errorf("no field named %q was found under type Comment", field.Name)
6313 },
6314 }
6315 return fc, nil
6316}
6317
6318func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
6319 fc, err := ec.fieldContext_CommentConnection_pageInfo(ctx, field)
6320 if err != nil {
6321 return graphql.Null
6322 }
6323 ctx = graphql.WithFieldContext(ctx, fc)
6324 defer func() {
6325 if r := recover(); r != nil {
6326 ec.Error(ctx, ec.Recover(ctx, r))
6327 ret = graphql.Null
6328 }
6329 }()
6330 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6331 ctx = rctx // use context from middleware stack in children
6332 return obj.PageInfo, nil
6333 })
6334 if err != nil {
6335 ec.Error(ctx, err)
6336 return graphql.Null
6337 }
6338 if resTmp == nil {
6339 if !graphql.HasFieldError(ctx, fc) {
6340 ec.Errorf(ctx, "must not be null")
6341 }
6342 return graphql.Null
6343 }
6344 res := resTmp.(*models.PageInfo)
6345 fc.Result = res
6346 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
6347}
6348
6349func (ec *executionContext) fieldContext_CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6350 fc = &graphql.FieldContext{
6351 Object: "CommentConnection",
6352 Field: field,
6353 IsMethod: false,
6354 IsResolver: false,
6355 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6356 switch field.Name {
6357 case "hasNextPage":
6358 return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
6359 case "hasPreviousPage":
6360 return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
6361 case "startCursor":
6362 return ec.fieldContext_PageInfo_startCursor(ctx, field)
6363 case "endCursor":
6364 return ec.fieldContext_PageInfo_endCursor(ctx, field)
6365 }
6366 return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
6367 },
6368 }
6369 return fc, nil
6370}
6371
6372func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
6373 fc, err := ec.fieldContext_CommentConnection_totalCount(ctx, field)
6374 if err != nil {
6375 return graphql.Null
6376 }
6377 ctx = graphql.WithFieldContext(ctx, fc)
6378 defer func() {
6379 if r := recover(); r != nil {
6380 ec.Error(ctx, ec.Recover(ctx, r))
6381 ret = graphql.Null
6382 }
6383 }()
6384 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6385 ctx = rctx // use context from middleware stack in children
6386 return obj.TotalCount, nil
6387 })
6388 if err != nil {
6389 ec.Error(ctx, err)
6390 return graphql.Null
6391 }
6392 if resTmp == nil {
6393 if !graphql.HasFieldError(ctx, fc) {
6394 ec.Errorf(ctx, "must not be null")
6395 }
6396 return graphql.Null
6397 }
6398 res := resTmp.(int)
6399 fc.Result = res
6400 return ec.marshalNInt2int(ctx, field.Selections, res)
6401}
6402
6403func (ec *executionContext) fieldContext_CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6404 fc = &graphql.FieldContext{
6405 Object: "CommentConnection",
6406 Field: field,
6407 IsMethod: false,
6408 IsResolver: false,
6409 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6410 return nil, errors.New("field of type Int does not have child fields")
6411 },
6412 }
6413 return fc, nil
6414}
6415
6416func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
6417 fc, err := ec.fieldContext_CommentEdge_cursor(ctx, field)
6418 if err != nil {
6419 return graphql.Null
6420 }
6421 ctx = graphql.WithFieldContext(ctx, fc)
6422 defer func() {
6423 if r := recover(); r != nil {
6424 ec.Error(ctx, ec.Recover(ctx, r))
6425 ret = graphql.Null
6426 }
6427 }()
6428 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6429 ctx = rctx // use context from middleware stack in children
6430 return obj.Cursor, nil
6431 })
6432 if err != nil {
6433 ec.Error(ctx, err)
6434 return graphql.Null
6435 }
6436 if resTmp == nil {
6437 if !graphql.HasFieldError(ctx, fc) {
6438 ec.Errorf(ctx, "must not be null")
6439 }
6440 return graphql.Null
6441 }
6442 res := resTmp.(string)
6443 fc.Result = res
6444 return ec.marshalNString2string(ctx, field.Selections, res)
6445}
6446
6447func (ec *executionContext) fieldContext_CommentEdge_cursor(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6448 fc = &graphql.FieldContext{
6449 Object: "CommentEdge",
6450 Field: field,
6451 IsMethod: false,
6452 IsResolver: false,
6453 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6454 return nil, errors.New("field of type String does not have child fields")
6455 },
6456 }
6457 return fc, nil
6458}
6459
6460func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
6461 fc, err := ec.fieldContext_CommentEdge_node(ctx, field)
6462 if err != nil {
6463 return graphql.Null
6464 }
6465 ctx = graphql.WithFieldContext(ctx, fc)
6466 defer func() {
6467 if r := recover(); r != nil {
6468 ec.Error(ctx, ec.Recover(ctx, r))
6469 ret = graphql.Null
6470 }
6471 }()
6472 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6473 ctx = rctx // use context from middleware stack in children
6474 return obj.Node, nil
6475 })
6476 if err != nil {
6477 ec.Error(ctx, err)
6478 return graphql.Null
6479 }
6480 if resTmp == nil {
6481 if !graphql.HasFieldError(ctx, fc) {
6482 ec.Errorf(ctx, "must not be null")
6483 }
6484 return graphql.Null
6485 }
6486 res := resTmp.(*bug.Comment)
6487 fc.Result = res
6488 return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
6489}
6490
6491func (ec *executionContext) fieldContext_CommentEdge_node(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6492 fc = &graphql.FieldContext{
6493 Object: "CommentEdge",
6494 Field: field,
6495 IsMethod: false,
6496 IsResolver: false,
6497 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6498 switch field.Name {
6499 case "author":
6500 return ec.fieldContext_Comment_author(ctx, field)
6501 case "message":
6502 return ec.fieldContext_Comment_message(ctx, field)
6503 case "files":
6504 return ec.fieldContext_Comment_files(ctx, field)
6505 }
6506 return nil, fmt.Errorf("no field named %q was found under type Comment", field.Name)
6507 },
6508 }
6509 return fc, nil
6510}
6511
6512func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
6513 fc, err := ec.fieldContext_CommentHistoryStep_message(ctx, field)
6514 if err != nil {
6515 return graphql.Null
6516 }
6517 ctx = graphql.WithFieldContext(ctx, fc)
6518 defer func() {
6519 if r := recover(); r != nil {
6520 ec.Error(ctx, ec.Recover(ctx, r))
6521 ret = graphql.Null
6522 }
6523 }()
6524 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6525 ctx = rctx // use context from middleware stack in children
6526 return obj.Message, nil
6527 })
6528 if err != nil {
6529 ec.Error(ctx, err)
6530 return graphql.Null
6531 }
6532 if resTmp == nil {
6533 if !graphql.HasFieldError(ctx, fc) {
6534 ec.Errorf(ctx, "must not be null")
6535 }
6536 return graphql.Null
6537 }
6538 res := resTmp.(string)
6539 fc.Result = res
6540 return ec.marshalNString2string(ctx, field.Selections, res)
6541}
6542
6543func (ec *executionContext) fieldContext_CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6544 fc = &graphql.FieldContext{
6545 Object: "CommentHistoryStep",
6546 Field: field,
6547 IsMethod: false,
6548 IsResolver: false,
6549 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6550 return nil, errors.New("field of type String does not have child fields")
6551 },
6552 }
6553 return fc, nil
6554}
6555
6556func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
6557 fc, err := ec.fieldContext_CommentHistoryStep_date(ctx, field)
6558 if err != nil {
6559 return graphql.Null
6560 }
6561 ctx = graphql.WithFieldContext(ctx, fc)
6562 defer func() {
6563 if r := recover(); r != nil {
6564 ec.Error(ctx, ec.Recover(ctx, r))
6565 ret = graphql.Null
6566 }
6567 }()
6568 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6569 ctx = rctx // use context from middleware stack in children
6570 return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
6571 })
6572 if err != nil {
6573 ec.Error(ctx, err)
6574 return graphql.Null
6575 }
6576 if resTmp == nil {
6577 if !graphql.HasFieldError(ctx, fc) {
6578 ec.Errorf(ctx, "must not be null")
6579 }
6580 return graphql.Null
6581 }
6582 res := resTmp.(*time.Time)
6583 fc.Result = res
6584 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6585}
6586
6587func (ec *executionContext) fieldContext_CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6588 fc = &graphql.FieldContext{
6589 Object: "CommentHistoryStep",
6590 Field: field,
6591 IsMethod: true,
6592 IsResolver: true,
6593 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6594 return nil, errors.New("field of type Time does not have child fields")
6595 },
6596 }
6597 return fc, nil
6598}
6599
6600func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
6601 fc, err := ec.fieldContext_CreateOperation_id(ctx, field)
6602 if err != nil {
6603 return graphql.Null
6604 }
6605 ctx = graphql.WithFieldContext(ctx, fc)
6606 defer func() {
6607 if r := recover(); r != nil {
6608 ec.Error(ctx, ec.Recover(ctx, r))
6609 ret = graphql.Null
6610 }
6611 }()
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.CreateOperation().ID(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.(string)
6627 fc.Result = res
6628 return ec.marshalNString2string(ctx, field.Selections, res)
6629}
6630
6631func (ec *executionContext) fieldContext_CreateOperation_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6632 fc = &graphql.FieldContext{
6633 Object: "CreateOperation",
6634 Field: field,
6635 IsMethod: true,
6636 IsResolver: true,
6637 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6638 return nil, errors.New("field of type String does not have child fields")
6639 },
6640 }
6641 return fc, nil
6642}
6643
6644func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
6645 fc, err := ec.fieldContext_CreateOperation_author(ctx, field)
6646 if err != nil {
6647 return graphql.Null
6648 }
6649 ctx = graphql.WithFieldContext(ctx, fc)
6650 defer func() {
6651 if r := recover(); r != nil {
6652 ec.Error(ctx, ec.Recover(ctx, r))
6653 ret = graphql.Null
6654 }
6655 }()
6656 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6657 ctx = rctx // use context from middleware stack in children
6658 return ec.resolvers.CreateOperation().Author(rctx, obj)
6659 })
6660 if err != nil {
6661 ec.Error(ctx, err)
6662 return graphql.Null
6663 }
6664 if resTmp == nil {
6665 if !graphql.HasFieldError(ctx, fc) {
6666 ec.Errorf(ctx, "must not be null")
6667 }
6668 return graphql.Null
6669 }
6670 res := resTmp.(models.IdentityWrapper)
6671 fc.Result = res
6672 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6673}
6674
6675func (ec *executionContext) fieldContext_CreateOperation_author(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6676 fc = &graphql.FieldContext{
6677 Object: "CreateOperation",
6678 Field: field,
6679 IsMethod: true,
6680 IsResolver: true,
6681 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6682 switch field.Name {
6683 case "id":
6684 return ec.fieldContext_Identity_id(ctx, field)
6685 case "humanId":
6686 return ec.fieldContext_Identity_humanId(ctx, field)
6687 case "name":
6688 return ec.fieldContext_Identity_name(ctx, field)
6689 case "email":
6690 return ec.fieldContext_Identity_email(ctx, field)
6691 case "login":
6692 return ec.fieldContext_Identity_login(ctx, field)
6693 case "displayName":
6694 return ec.fieldContext_Identity_displayName(ctx, field)
6695 case "avatarUrl":
6696 return ec.fieldContext_Identity_avatarUrl(ctx, field)
6697 case "isProtected":
6698 return ec.fieldContext_Identity_isProtected(ctx, field)
6699 }
6700 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
6701 },
6702 }
6703 return fc, nil
6704}
6705
6706func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
6707 fc, err := ec.fieldContext_CreateOperation_date(ctx, field)
6708 if err != nil {
6709 return graphql.Null
6710 }
6711 ctx = graphql.WithFieldContext(ctx, fc)
6712 defer func() {
6713 if r := recover(); r != nil {
6714 ec.Error(ctx, ec.Recover(ctx, r))
6715 ret = graphql.Null
6716 }
6717 }()
6718 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6719 ctx = rctx // use context from middleware stack in children
6720 return ec.resolvers.CreateOperation().Date(rctx, obj)
6721 })
6722 if err != nil {
6723 ec.Error(ctx, err)
6724 return graphql.Null
6725 }
6726 if resTmp == nil {
6727 if !graphql.HasFieldError(ctx, fc) {
6728 ec.Errorf(ctx, "must not be null")
6729 }
6730 return graphql.Null
6731 }
6732 res := resTmp.(*time.Time)
6733 fc.Result = res
6734 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6735}
6736
6737func (ec *executionContext) fieldContext_CreateOperation_date(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6738 fc = &graphql.FieldContext{
6739 Object: "CreateOperation",
6740 Field: field,
6741 IsMethod: true,
6742 IsResolver: true,
6743 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6744 return nil, errors.New("field of type Time does not have child fields")
6745 },
6746 }
6747 return fc, nil
6748}
6749
6750func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
6751 fc, err := ec.fieldContext_CreateOperation_title(ctx, field)
6752 if err != nil {
6753 return graphql.Null
6754 }
6755 ctx = graphql.WithFieldContext(ctx, fc)
6756 defer func() {
6757 if r := recover(); r != nil {
6758 ec.Error(ctx, ec.Recover(ctx, r))
6759 ret = graphql.Null
6760 }
6761 }()
6762 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6763 ctx = rctx // use context from middleware stack in children
6764 return obj.Title, nil
6765 })
6766 if err != nil {
6767 ec.Error(ctx, err)
6768 return graphql.Null
6769 }
6770 if resTmp == nil {
6771 if !graphql.HasFieldError(ctx, fc) {
6772 ec.Errorf(ctx, "must not be null")
6773 }
6774 return graphql.Null
6775 }
6776 res := resTmp.(string)
6777 fc.Result = res
6778 return ec.marshalNString2string(ctx, field.Selections, res)
6779}
6780
6781func (ec *executionContext) fieldContext_CreateOperation_title(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6782 fc = &graphql.FieldContext{
6783 Object: "CreateOperation",
6784 Field: field,
6785 IsMethod: false,
6786 IsResolver: false,
6787 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6788 return nil, errors.New("field of type String does not have child fields")
6789 },
6790 }
6791 return fc, nil
6792}
6793
6794func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
6795 fc, err := ec.fieldContext_CreateOperation_message(ctx, field)
6796 if err != nil {
6797 return graphql.Null
6798 }
6799 ctx = graphql.WithFieldContext(ctx, fc)
6800 defer func() {
6801 if r := recover(); r != nil {
6802 ec.Error(ctx, ec.Recover(ctx, r))
6803 ret = graphql.Null
6804 }
6805 }()
6806 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6807 ctx = rctx // use context from middleware stack in children
6808 return obj.Message, nil
6809 })
6810 if err != nil {
6811 ec.Error(ctx, err)
6812 return graphql.Null
6813 }
6814 if resTmp == nil {
6815 if !graphql.HasFieldError(ctx, fc) {
6816 ec.Errorf(ctx, "must not be null")
6817 }
6818 return graphql.Null
6819 }
6820 res := resTmp.(string)
6821 fc.Result = res
6822 return ec.marshalNString2string(ctx, field.Selections, res)
6823}
6824
6825func (ec *executionContext) fieldContext_CreateOperation_message(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6826 fc = &graphql.FieldContext{
6827 Object: "CreateOperation",
6828 Field: field,
6829 IsMethod: false,
6830 IsResolver: false,
6831 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6832 return nil, errors.New("field of type String does not have child fields")
6833 },
6834 }
6835 return fc, nil
6836}
6837
6838func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
6839 fc, err := ec.fieldContext_CreateOperation_files(ctx, field)
6840 if err != nil {
6841 return graphql.Null
6842 }
6843 ctx = graphql.WithFieldContext(ctx, fc)
6844 defer func() {
6845 if r := recover(); r != nil {
6846 ec.Error(ctx, ec.Recover(ctx, r))
6847 ret = graphql.Null
6848 }
6849 }()
6850 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6851 ctx = rctx // use context from middleware stack in children
6852 return obj.Files, nil
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.([]repository.Hash)
6865 fc.Result = res
6866 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
6867}
6868
6869func (ec *executionContext) fieldContext_CreateOperation_files(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6870 fc = &graphql.FieldContext{
6871 Object: "CreateOperation",
6872 Field: field,
6873 IsMethod: false,
6874 IsResolver: false,
6875 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6876 return nil, errors.New("field of type Hash does not have child fields")
6877 },
6878 }
6879 return fc, nil
6880}
6881
6882func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
6883 fc, err := ec.fieldContext_CreateTimelineItem_id(ctx, field)
6884 if err != nil {
6885 return graphql.Null
6886 }
6887 ctx = graphql.WithFieldContext(ctx, fc)
6888 defer func() {
6889 if r := recover(); r != nil {
6890 ec.Error(ctx, ec.Recover(ctx, r))
6891 ret = graphql.Null
6892 }
6893 }()
6894 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6895 ctx = rctx // use context from middleware stack in children
6896 return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
6897 })
6898 if err != nil {
6899 ec.Error(ctx, err)
6900 return graphql.Null
6901 }
6902 if resTmp == nil {
6903 if !graphql.HasFieldError(ctx, fc) {
6904 ec.Errorf(ctx, "must not be null")
6905 }
6906 return graphql.Null
6907 }
6908 res := resTmp.(string)
6909 fc.Result = res
6910 return ec.marshalNString2string(ctx, field.Selections, res)
6911}
6912
6913func (ec *executionContext) fieldContext_CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6914 fc = &graphql.FieldContext{
6915 Object: "CreateTimelineItem",
6916 Field: field,
6917 IsMethod: true,
6918 IsResolver: true,
6919 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6920 return nil, errors.New("field of type String does not have child fields")
6921 },
6922 }
6923 return fc, nil
6924}
6925
6926func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
6927 fc, err := ec.fieldContext_CreateTimelineItem_author(ctx, field)
6928 if err != nil {
6929 return graphql.Null
6930 }
6931 ctx = graphql.WithFieldContext(ctx, fc)
6932 defer func() {
6933 if r := recover(); r != nil {
6934 ec.Error(ctx, ec.Recover(ctx, r))
6935 ret = graphql.Null
6936 }
6937 }()
6938 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6939 ctx = rctx // use context from middleware stack in children
6940 return ec.resolvers.CreateTimelineItem().Author(rctx, obj)
6941 })
6942 if err != nil {
6943 ec.Error(ctx, err)
6944 return graphql.Null
6945 }
6946 if resTmp == nil {
6947 if !graphql.HasFieldError(ctx, fc) {
6948 ec.Errorf(ctx, "must not be null")
6949 }
6950 return graphql.Null
6951 }
6952 res := resTmp.(models.IdentityWrapper)
6953 fc.Result = res
6954 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6955}
6956
6957func (ec *executionContext) fieldContext_CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6958 fc = &graphql.FieldContext{
6959 Object: "CreateTimelineItem",
6960 Field: field,
6961 IsMethod: true,
6962 IsResolver: true,
6963 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6964 switch field.Name {
6965 case "id":
6966 return ec.fieldContext_Identity_id(ctx, field)
6967 case "humanId":
6968 return ec.fieldContext_Identity_humanId(ctx, field)
6969 case "name":
6970 return ec.fieldContext_Identity_name(ctx, field)
6971 case "email":
6972 return ec.fieldContext_Identity_email(ctx, field)
6973 case "login":
6974 return ec.fieldContext_Identity_login(ctx, field)
6975 case "displayName":
6976 return ec.fieldContext_Identity_displayName(ctx, field)
6977 case "avatarUrl":
6978 return ec.fieldContext_Identity_avatarUrl(ctx, field)
6979 case "isProtected":
6980 return ec.fieldContext_Identity_isProtected(ctx, field)
6981 }
6982 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
6983 },
6984 }
6985 return fc, nil
6986}
6987
6988func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
6989 fc, err := ec.fieldContext_CreateTimelineItem_message(ctx, field)
6990 if err != nil {
6991 return graphql.Null
6992 }
6993 ctx = graphql.WithFieldContext(ctx, fc)
6994 defer func() {
6995 if r := recover(); r != nil {
6996 ec.Error(ctx, ec.Recover(ctx, r))
6997 ret = graphql.Null
6998 }
6999 }()
7000 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7001 ctx = rctx // use context from middleware stack in children
7002 return obj.Message, nil
7003 })
7004 if err != nil {
7005 ec.Error(ctx, err)
7006 return graphql.Null
7007 }
7008 if resTmp == nil {
7009 if !graphql.HasFieldError(ctx, fc) {
7010 ec.Errorf(ctx, "must not be null")
7011 }
7012 return graphql.Null
7013 }
7014 res := resTmp.(string)
7015 fc.Result = res
7016 return ec.marshalNString2string(ctx, field.Selections, res)
7017}
7018
7019func (ec *executionContext) fieldContext_CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7020 fc = &graphql.FieldContext{
7021 Object: "CreateTimelineItem",
7022 Field: field,
7023 IsMethod: false,
7024 IsResolver: false,
7025 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7026 return nil, errors.New("field of type String does not have child fields")
7027 },
7028 }
7029 return fc, nil
7030}
7031
7032func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
7033 fc, err := ec.fieldContext_CreateTimelineItem_messageIsEmpty(ctx, field)
7034 if err != nil {
7035 return graphql.Null
7036 }
7037 ctx = graphql.WithFieldContext(ctx, fc)
7038 defer func() {
7039 if r := recover(); r != nil {
7040 ec.Error(ctx, ec.Recover(ctx, r))
7041 ret = graphql.Null
7042 }
7043 }()
7044 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7045 ctx = rctx // use context from middleware stack in children
7046 return obj.MessageIsEmpty(), nil
7047 })
7048 if err != nil {
7049 ec.Error(ctx, err)
7050 return graphql.Null
7051 }
7052 if resTmp == nil {
7053 if !graphql.HasFieldError(ctx, fc) {
7054 ec.Errorf(ctx, "must not be null")
7055 }
7056 return graphql.Null
7057 }
7058 res := resTmp.(bool)
7059 fc.Result = res
7060 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
7061}
7062
7063func (ec *executionContext) fieldContext_CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7064 fc = &graphql.FieldContext{
7065 Object: "CreateTimelineItem",
7066 Field: field,
7067 IsMethod: true,
7068 IsResolver: false,
7069 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7070 return nil, errors.New("field of type Boolean does not have child fields")
7071 },
7072 }
7073 return fc, nil
7074}
7075
7076func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
7077 fc, err := ec.fieldContext_CreateTimelineItem_files(ctx, field)
7078 if err != nil {
7079 return graphql.Null
7080 }
7081 ctx = graphql.WithFieldContext(ctx, fc)
7082 defer func() {
7083 if r := recover(); r != nil {
7084 ec.Error(ctx, ec.Recover(ctx, r))
7085 ret = graphql.Null
7086 }
7087 }()
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.Files, 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.([]repository.Hash)
7103 fc.Result = res
7104 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
7105}
7106
7107func (ec *executionContext) fieldContext_CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7108 fc = &graphql.FieldContext{
7109 Object: "CreateTimelineItem",
7110 Field: field,
7111 IsMethod: false,
7112 IsResolver: false,
7113 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7114 return nil, errors.New("field of type Hash does not have child fields")
7115 },
7116 }
7117 return fc, nil
7118}
7119
7120func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
7121 fc, err := ec.fieldContext_CreateTimelineItem_createdAt(ctx, field)
7122 if err != nil {
7123 return graphql.Null
7124 }
7125 ctx = graphql.WithFieldContext(ctx, fc)
7126 defer func() {
7127 if r := recover(); r != nil {
7128 ec.Error(ctx, ec.Recover(ctx, r))
7129 ret = graphql.Null
7130 }
7131 }()
7132 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7133 ctx = rctx // use context from middleware stack in children
7134 return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
7135 })
7136 if err != nil {
7137 ec.Error(ctx, err)
7138 return graphql.Null
7139 }
7140 if resTmp == nil {
7141 if !graphql.HasFieldError(ctx, fc) {
7142 ec.Errorf(ctx, "must not be null")
7143 }
7144 return graphql.Null
7145 }
7146 res := resTmp.(*time.Time)
7147 fc.Result = res
7148 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
7149}
7150
7151func (ec *executionContext) fieldContext_CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7152 fc = &graphql.FieldContext{
7153 Object: "CreateTimelineItem",
7154 Field: field,
7155 IsMethod: true,
7156 IsResolver: true,
7157 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7158 return nil, errors.New("field of type Time does not have child fields")
7159 },
7160 }
7161 return fc, nil
7162}
7163
7164func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
7165 fc, err := ec.fieldContext_CreateTimelineItem_lastEdit(ctx, field)
7166 if err != nil {
7167 return graphql.Null
7168 }
7169 ctx = graphql.WithFieldContext(ctx, fc)
7170 defer func() {
7171 if r := recover(); r != nil {
7172 ec.Error(ctx, ec.Recover(ctx, r))
7173 ret = graphql.Null
7174 }
7175 }()
7176 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7177 ctx = rctx // use context from middleware stack in children
7178 return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
7179 })
7180 if err != nil {
7181 ec.Error(ctx, err)
7182 return graphql.Null
7183 }
7184 if resTmp == nil {
7185 if !graphql.HasFieldError(ctx, fc) {
7186 ec.Errorf(ctx, "must not be null")
7187 }
7188 return graphql.Null
7189 }
7190 res := resTmp.(*time.Time)
7191 fc.Result = res
7192 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
7193}
7194
7195func (ec *executionContext) fieldContext_CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7196 fc = &graphql.FieldContext{
7197 Object: "CreateTimelineItem",
7198 Field: field,
7199 IsMethod: true,
7200 IsResolver: true,
7201 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7202 return nil, errors.New("field of type Time does not have child fields")
7203 },
7204 }
7205 return fc, nil
7206}
7207
7208func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
7209 fc, err := ec.fieldContext_CreateTimelineItem_edited(ctx, field)
7210 if err != nil {
7211 return graphql.Null
7212 }
7213 ctx = graphql.WithFieldContext(ctx, fc)
7214 defer func() {
7215 if r := recover(); r != nil {
7216 ec.Error(ctx, ec.Recover(ctx, r))
7217 ret = graphql.Null
7218 }
7219 }()
7220 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7221 ctx = rctx // use context from middleware stack in children
7222 return obj.Edited(), nil
7223 })
7224 if err != nil {
7225 ec.Error(ctx, err)
7226 return graphql.Null
7227 }
7228 if resTmp == nil {
7229 if !graphql.HasFieldError(ctx, fc) {
7230 ec.Errorf(ctx, "must not be null")
7231 }
7232 return graphql.Null
7233 }
7234 res := resTmp.(bool)
7235 fc.Result = res
7236 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
7237}
7238
7239func (ec *executionContext) fieldContext_CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7240 fc = &graphql.FieldContext{
7241 Object: "CreateTimelineItem",
7242 Field: field,
7243 IsMethod: true,
7244 IsResolver: false,
7245 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7246 return nil, errors.New("field of type Boolean does not have child fields")
7247 },
7248 }
7249 return fc, nil
7250}
7251
7252func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
7253 fc, err := ec.fieldContext_CreateTimelineItem_history(ctx, field)
7254 if err != nil {
7255 return graphql.Null
7256 }
7257 ctx = graphql.WithFieldContext(ctx, fc)
7258 defer func() {
7259 if r := recover(); r != nil {
7260 ec.Error(ctx, ec.Recover(ctx, r))
7261 ret = graphql.Null
7262 }
7263 }()
7264 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7265 ctx = rctx // use context from middleware stack in children
7266 return obj.History, nil
7267 })
7268 if err != nil {
7269 ec.Error(ctx, err)
7270 return graphql.Null
7271 }
7272 if resTmp == nil {
7273 if !graphql.HasFieldError(ctx, fc) {
7274 ec.Errorf(ctx, "must not be null")
7275 }
7276 return graphql.Null
7277 }
7278 res := resTmp.([]bug.CommentHistoryStep)
7279 fc.Result = res
7280 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
7281}
7282
7283func (ec *executionContext) fieldContext_CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7284 fc = &graphql.FieldContext{
7285 Object: "CreateTimelineItem",
7286 Field: field,
7287 IsMethod: false,
7288 IsResolver: false,
7289 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7290 switch field.Name {
7291 case "message":
7292 return ec.fieldContext_CommentHistoryStep_message(ctx, field)
7293 case "date":
7294 return ec.fieldContext_CommentHistoryStep_date(ctx, field)
7295 }
7296 return nil, fmt.Errorf("no field named %q was found under type CommentHistoryStep", field.Name)
7297 },
7298 }
7299 return fc, nil
7300}
7301
7302func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
7303 fc, err := ec.fieldContext_EditCommentOperation_id(ctx, field)
7304 if err != nil {
7305 return graphql.Null
7306 }
7307 ctx = graphql.WithFieldContext(ctx, fc)
7308 defer func() {
7309 if r := recover(); r != nil {
7310 ec.Error(ctx, ec.Recover(ctx, r))
7311 ret = graphql.Null
7312 }
7313 }()
7314 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7315 ctx = rctx // use context from middleware stack in children
7316 return ec.resolvers.EditCommentOperation().ID(rctx, obj)
7317 })
7318 if err != nil {
7319 ec.Error(ctx, err)
7320 return graphql.Null
7321 }
7322 if resTmp == nil {
7323 if !graphql.HasFieldError(ctx, fc) {
7324 ec.Errorf(ctx, "must not be null")
7325 }
7326 return graphql.Null
7327 }
7328 res := resTmp.(string)
7329 fc.Result = res
7330 return ec.marshalNString2string(ctx, field.Selections, res)
7331}
7332
7333func (ec *executionContext) fieldContext_EditCommentOperation_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7334 fc = &graphql.FieldContext{
7335 Object: "EditCommentOperation",
7336 Field: field,
7337 IsMethod: true,
7338 IsResolver: true,
7339 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7340 return nil, errors.New("field of type String does not have child fields")
7341 },
7342 }
7343 return fc, nil
7344}
7345
7346func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
7347 fc, err := ec.fieldContext_EditCommentOperation_author(ctx, field)
7348 if err != nil {
7349 return graphql.Null
7350 }
7351 ctx = graphql.WithFieldContext(ctx, fc)
7352 defer func() {
7353 if r := recover(); r != nil {
7354 ec.Error(ctx, ec.Recover(ctx, r))
7355 ret = graphql.Null
7356 }
7357 }()
7358 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7359 ctx = rctx // use context from middleware stack in children
7360 return ec.resolvers.EditCommentOperation().Author(rctx, obj)
7361 })
7362 if err != nil {
7363 ec.Error(ctx, err)
7364 return graphql.Null
7365 }
7366 if resTmp == nil {
7367 if !graphql.HasFieldError(ctx, fc) {
7368 ec.Errorf(ctx, "must not be null")
7369 }
7370 return graphql.Null
7371 }
7372 res := resTmp.(models.IdentityWrapper)
7373 fc.Result = res
7374 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
7375}
7376
7377func (ec *executionContext) fieldContext_EditCommentOperation_author(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7378 fc = &graphql.FieldContext{
7379 Object: "EditCommentOperation",
7380 Field: field,
7381 IsMethod: true,
7382 IsResolver: true,
7383 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7384 switch field.Name {
7385 case "id":
7386 return ec.fieldContext_Identity_id(ctx, field)
7387 case "humanId":
7388 return ec.fieldContext_Identity_humanId(ctx, field)
7389 case "name":
7390 return ec.fieldContext_Identity_name(ctx, field)
7391 case "email":
7392 return ec.fieldContext_Identity_email(ctx, field)
7393 case "login":
7394 return ec.fieldContext_Identity_login(ctx, field)
7395 case "displayName":
7396 return ec.fieldContext_Identity_displayName(ctx, field)
7397 case "avatarUrl":
7398 return ec.fieldContext_Identity_avatarUrl(ctx, field)
7399 case "isProtected":
7400 return ec.fieldContext_Identity_isProtected(ctx, field)
7401 }
7402 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
7403 },
7404 }
7405 return fc, nil
7406}
7407
7408func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
7409 fc, err := ec.fieldContext_EditCommentOperation_date(ctx, field)
7410 if err != nil {
7411 return graphql.Null
7412 }
7413 ctx = graphql.WithFieldContext(ctx, fc)
7414 defer func() {
7415 if r := recover(); r != nil {
7416 ec.Error(ctx, ec.Recover(ctx, r))
7417 ret = graphql.Null
7418 }
7419 }()
7420 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7421 ctx = rctx // use context from middleware stack in children
7422 return ec.resolvers.EditCommentOperation().Date(rctx, obj)
7423 })
7424 if err != nil {
7425 ec.Error(ctx, err)
7426 return graphql.Null
7427 }
7428 if resTmp == nil {
7429 if !graphql.HasFieldError(ctx, fc) {
7430 ec.Errorf(ctx, "must not be null")
7431 }
7432 return graphql.Null
7433 }
7434 res := resTmp.(*time.Time)
7435 fc.Result = res
7436 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
7437}
7438
7439func (ec *executionContext) fieldContext_EditCommentOperation_date(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7440 fc = &graphql.FieldContext{
7441 Object: "EditCommentOperation",
7442 Field: field,
7443 IsMethod: true,
7444 IsResolver: true,
7445 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7446 return nil, errors.New("field of type Time does not have child fields")
7447 },
7448 }
7449 return fc, nil
7450}
7451
7452func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
7453 fc, err := ec.fieldContext_EditCommentOperation_target(ctx, field)
7454 if err != nil {
7455 return graphql.Null
7456 }
7457 ctx = graphql.WithFieldContext(ctx, fc)
7458 defer func() {
7459 if r := recover(); r != nil {
7460 ec.Error(ctx, ec.Recover(ctx, r))
7461 ret = graphql.Null
7462 }
7463 }()
7464 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7465 ctx = rctx // use context from middleware stack in children
7466 return ec.resolvers.EditCommentOperation().Target(rctx, obj)
7467 })
7468 if err != nil {
7469 ec.Error(ctx, err)
7470 return graphql.Null
7471 }
7472 if resTmp == nil {
7473 if !graphql.HasFieldError(ctx, fc) {
7474 ec.Errorf(ctx, "must not be null")
7475 }
7476 return graphql.Null
7477 }
7478 res := resTmp.(string)
7479 fc.Result = res
7480 return ec.marshalNString2string(ctx, field.Selections, res)
7481}
7482
7483func (ec *executionContext) fieldContext_EditCommentOperation_target(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7484 fc = &graphql.FieldContext{
7485 Object: "EditCommentOperation",
7486 Field: field,
7487 IsMethod: true,
7488 IsResolver: true,
7489 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7490 return nil, errors.New("field of type String does not have child fields")
7491 },
7492 }
7493 return fc, nil
7494}
7495
7496func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
7497 fc, err := ec.fieldContext_EditCommentOperation_message(ctx, field)
7498 if err != nil {
7499 return graphql.Null
7500 }
7501 ctx = graphql.WithFieldContext(ctx, fc)
7502 defer func() {
7503 if r := recover(); r != nil {
7504 ec.Error(ctx, ec.Recover(ctx, r))
7505 ret = graphql.Null
7506 }
7507 }()
7508 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7509 ctx = rctx // use context from middleware stack in children
7510 return obj.Message, nil
7511 })
7512 if err != nil {
7513 ec.Error(ctx, err)
7514 return graphql.Null
7515 }
7516 if resTmp == nil {
7517 if !graphql.HasFieldError(ctx, fc) {
7518 ec.Errorf(ctx, "must not be null")
7519 }
7520 return graphql.Null
7521 }
7522 res := resTmp.(string)
7523 fc.Result = res
7524 return ec.marshalNString2string(ctx, field.Selections, res)
7525}
7526
7527func (ec *executionContext) fieldContext_EditCommentOperation_message(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7528 fc = &graphql.FieldContext{
7529 Object: "EditCommentOperation",
7530 Field: field,
7531 IsMethod: false,
7532 IsResolver: false,
7533 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7534 return nil, errors.New("field of type String does not have child fields")
7535 },
7536 }
7537 return fc, nil
7538}
7539
7540func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
7541 fc, err := ec.fieldContext_EditCommentOperation_files(ctx, field)
7542 if err != nil {
7543 return graphql.Null
7544 }
7545 ctx = graphql.WithFieldContext(ctx, fc)
7546 defer func() {
7547 if r := recover(); r != nil {
7548 ec.Error(ctx, ec.Recover(ctx, r))
7549 ret = graphql.Null
7550 }
7551 }()
7552 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7553 ctx = rctx // use context from middleware stack in children
7554 return obj.Files, nil
7555 })
7556 if err != nil {
7557 ec.Error(ctx, err)
7558 return graphql.Null
7559 }
7560 if resTmp == nil {
7561 if !graphql.HasFieldError(ctx, fc) {
7562 ec.Errorf(ctx, "must not be null")
7563 }
7564 return graphql.Null
7565 }
7566 res := resTmp.([]repository.Hash)
7567 fc.Result = res
7568 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
7569}
7570
7571func (ec *executionContext) fieldContext_EditCommentOperation_files(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7572 fc = &graphql.FieldContext{
7573 Object: "EditCommentOperation",
7574 Field: field,
7575 IsMethod: false,
7576 IsResolver: false,
7577 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7578 return nil, errors.New("field of type Hash does not have child fields")
7579 },
7580 }
7581 return fc, nil
7582}
7583
7584func (ec *executionContext) _EditCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
7585 fc, err := ec.fieldContext_EditCommentPayload_clientMutationId(ctx, field)
7586 if err != nil {
7587 return graphql.Null
7588 }
7589 ctx = graphql.WithFieldContext(ctx, fc)
7590 defer func() {
7591 if r := recover(); r != nil {
7592 ec.Error(ctx, ec.Recover(ctx, r))
7593 ret = graphql.Null
7594 }
7595 }()
7596 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7597 ctx = rctx // use context from middleware stack in children
7598 return obj.ClientMutationID, nil
7599 })
7600 if err != nil {
7601 ec.Error(ctx, err)
7602 return graphql.Null
7603 }
7604 if resTmp == nil {
7605 return graphql.Null
7606 }
7607 res := resTmp.(*string)
7608 fc.Result = res
7609 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7610}
7611
7612func (ec *executionContext) fieldContext_EditCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7613 fc = &graphql.FieldContext{
7614 Object: "EditCommentPayload",
7615 Field: field,
7616 IsMethod: false,
7617 IsResolver: false,
7618 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7619 return nil, errors.New("field of type String does not have child fields")
7620 },
7621 }
7622 return fc, nil
7623}
7624
7625func (ec *executionContext) _EditCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
7626 fc, err := ec.fieldContext_EditCommentPayload_bug(ctx, field)
7627 if err != nil {
7628 return graphql.Null
7629 }
7630 ctx = graphql.WithFieldContext(ctx, fc)
7631 defer func() {
7632 if r := recover(); r != nil {
7633 ec.Error(ctx, ec.Recover(ctx, r))
7634 ret = graphql.Null
7635 }
7636 }()
7637 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7638 ctx = rctx // use context from middleware stack in children
7639 return obj.Bug, nil
7640 })
7641 if err != nil {
7642 ec.Error(ctx, err)
7643 return graphql.Null
7644 }
7645 if resTmp == nil {
7646 if !graphql.HasFieldError(ctx, fc) {
7647 ec.Errorf(ctx, "must not be null")
7648 }
7649 return graphql.Null
7650 }
7651 res := resTmp.(models.BugWrapper)
7652 fc.Result = res
7653 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
7654}
7655
7656func (ec *executionContext) fieldContext_EditCommentPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7657 fc = &graphql.FieldContext{
7658 Object: "EditCommentPayload",
7659 Field: field,
7660 IsMethod: false,
7661 IsResolver: false,
7662 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7663 switch field.Name {
7664 case "id":
7665 return ec.fieldContext_Bug_id(ctx, field)
7666 case "humanId":
7667 return ec.fieldContext_Bug_humanId(ctx, field)
7668 case "status":
7669 return ec.fieldContext_Bug_status(ctx, field)
7670 case "title":
7671 return ec.fieldContext_Bug_title(ctx, field)
7672 case "labels":
7673 return ec.fieldContext_Bug_labels(ctx, field)
7674 case "author":
7675 return ec.fieldContext_Bug_author(ctx, field)
7676 case "createdAt":
7677 return ec.fieldContext_Bug_createdAt(ctx, field)
7678 case "lastEdit":
7679 return ec.fieldContext_Bug_lastEdit(ctx, field)
7680 case "actors":
7681 return ec.fieldContext_Bug_actors(ctx, field)
7682 case "participants":
7683 return ec.fieldContext_Bug_participants(ctx, field)
7684 case "comments":
7685 return ec.fieldContext_Bug_comments(ctx, field)
7686 case "timeline":
7687 return ec.fieldContext_Bug_timeline(ctx, field)
7688 case "operations":
7689 return ec.fieldContext_Bug_operations(ctx, field)
7690 }
7691 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
7692 },
7693 }
7694 return fc, nil
7695}
7696
7697func (ec *executionContext) _EditCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
7698 fc, err := ec.fieldContext_EditCommentPayload_operation(ctx, field)
7699 if err != nil {
7700 return graphql.Null
7701 }
7702 ctx = graphql.WithFieldContext(ctx, fc)
7703 defer func() {
7704 if r := recover(); r != nil {
7705 ec.Error(ctx, ec.Recover(ctx, r))
7706 ret = graphql.Null
7707 }
7708 }()
7709 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7710 ctx = rctx // use context from middleware stack in children
7711 return obj.Operation, nil
7712 })
7713 if err != nil {
7714 ec.Error(ctx, err)
7715 return graphql.Null
7716 }
7717 if resTmp == nil {
7718 if !graphql.HasFieldError(ctx, fc) {
7719 ec.Errorf(ctx, "must not be null")
7720 }
7721 return graphql.Null
7722 }
7723 res := resTmp.(*bug.EditCommentOperation)
7724 fc.Result = res
7725 return ec.marshalNEditCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐEditCommentOperation(ctx, field.Selections, res)
7726}
7727
7728func (ec *executionContext) fieldContext_EditCommentPayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7729 fc = &graphql.FieldContext{
7730 Object: "EditCommentPayload",
7731 Field: field,
7732 IsMethod: false,
7733 IsResolver: false,
7734 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7735 switch field.Name {
7736 case "id":
7737 return ec.fieldContext_EditCommentOperation_id(ctx, field)
7738 case "author":
7739 return ec.fieldContext_EditCommentOperation_author(ctx, field)
7740 case "date":
7741 return ec.fieldContext_EditCommentOperation_date(ctx, field)
7742 case "target":
7743 return ec.fieldContext_EditCommentOperation_target(ctx, field)
7744 case "message":
7745 return ec.fieldContext_EditCommentOperation_message(ctx, field)
7746 case "files":
7747 return ec.fieldContext_EditCommentOperation_files(ctx, field)
7748 }
7749 return nil, fmt.Errorf("no field named %q was found under type EditCommentOperation", field.Name)
7750 },
7751 }
7752 return fc, nil
7753}
7754
7755func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
7756 fc, err := ec.fieldContext_Identity_id(ctx, field)
7757 if err != nil {
7758 return graphql.Null
7759 }
7760 ctx = graphql.WithFieldContext(ctx, fc)
7761 defer func() {
7762 if r := recover(); r != nil {
7763 ec.Error(ctx, ec.Recover(ctx, r))
7764 ret = graphql.Null
7765 }
7766 }()
7767 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7768 ctx = rctx // use context from middleware stack in children
7769 return ec.resolvers.Identity().ID(rctx, obj)
7770 })
7771 if err != nil {
7772 ec.Error(ctx, err)
7773 return graphql.Null
7774 }
7775 if resTmp == nil {
7776 if !graphql.HasFieldError(ctx, fc) {
7777 ec.Errorf(ctx, "must not be null")
7778 }
7779 return graphql.Null
7780 }
7781 res := resTmp.(string)
7782 fc.Result = res
7783 return ec.marshalNString2string(ctx, field.Selections, res)
7784}
7785
7786func (ec *executionContext) fieldContext_Identity_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7787 fc = &graphql.FieldContext{
7788 Object: "Identity",
7789 Field: field,
7790 IsMethod: true,
7791 IsResolver: true,
7792 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7793 return nil, errors.New("field of type String does not have child fields")
7794 },
7795 }
7796 return fc, nil
7797}
7798
7799func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
7800 fc, err := ec.fieldContext_Identity_humanId(ctx, field)
7801 if err != nil {
7802 return graphql.Null
7803 }
7804 ctx = graphql.WithFieldContext(ctx, fc)
7805 defer func() {
7806 if r := recover(); r != nil {
7807 ec.Error(ctx, ec.Recover(ctx, r))
7808 ret = graphql.Null
7809 }
7810 }()
7811 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7812 ctx = rctx // use context from middleware stack in children
7813 return ec.resolvers.Identity().HumanID(rctx, obj)
7814 })
7815 if err != nil {
7816 ec.Error(ctx, err)
7817 return graphql.Null
7818 }
7819 if resTmp == nil {
7820 if !graphql.HasFieldError(ctx, fc) {
7821 ec.Errorf(ctx, "must not be null")
7822 }
7823 return graphql.Null
7824 }
7825 res := resTmp.(string)
7826 fc.Result = res
7827 return ec.marshalNString2string(ctx, field.Selections, res)
7828}
7829
7830func (ec *executionContext) fieldContext_Identity_humanId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7831 fc = &graphql.FieldContext{
7832 Object: "Identity",
7833 Field: field,
7834 IsMethod: true,
7835 IsResolver: true,
7836 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7837 return nil, errors.New("field of type String does not have child fields")
7838 },
7839 }
7840 return fc, nil
7841}
7842
7843func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
7844 fc, err := ec.fieldContext_Identity_name(ctx, field)
7845 if err != nil {
7846 return graphql.Null
7847 }
7848 ctx = graphql.WithFieldContext(ctx, fc)
7849 defer func() {
7850 if r := recover(); r != nil {
7851 ec.Error(ctx, ec.Recover(ctx, r))
7852 ret = graphql.Null
7853 }
7854 }()
7855 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7856 ctx = rctx // use context from middleware stack in children
7857 return obj.Name(), nil
7858 })
7859 if err != nil {
7860 ec.Error(ctx, err)
7861 return graphql.Null
7862 }
7863 if resTmp == nil {
7864 return graphql.Null
7865 }
7866 res := resTmp.(string)
7867 fc.Result = res
7868 return ec.marshalOString2string(ctx, field.Selections, res)
7869}
7870
7871func (ec *executionContext) fieldContext_Identity_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7872 fc = &graphql.FieldContext{
7873 Object: "Identity",
7874 Field: field,
7875 IsMethod: true,
7876 IsResolver: false,
7877 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7878 return nil, errors.New("field of type String does not have child fields")
7879 },
7880 }
7881 return fc, nil
7882}
7883
7884func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
7885 fc, err := ec.fieldContext_Identity_email(ctx, field)
7886 if err != nil {
7887 return graphql.Null
7888 }
7889 ctx = graphql.WithFieldContext(ctx, fc)
7890 defer func() {
7891 if r := recover(); r != nil {
7892 ec.Error(ctx, ec.Recover(ctx, r))
7893 ret = graphql.Null
7894 }
7895 }()
7896 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7897 ctx = rctx // use context from middleware stack in children
7898 return obj.Email()
7899 })
7900 if err != nil {
7901 ec.Error(ctx, err)
7902 return graphql.Null
7903 }
7904 if resTmp == nil {
7905 return graphql.Null
7906 }
7907 res := resTmp.(string)
7908 fc.Result = res
7909 return ec.marshalOString2string(ctx, field.Selections, res)
7910}
7911
7912func (ec *executionContext) fieldContext_Identity_email(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7913 fc = &graphql.FieldContext{
7914 Object: "Identity",
7915 Field: field,
7916 IsMethod: true,
7917 IsResolver: false,
7918 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7919 return nil, errors.New("field of type String does not have child fields")
7920 },
7921 }
7922 return fc, nil
7923}
7924
7925func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
7926 fc, err := ec.fieldContext_Identity_login(ctx, field)
7927 if err != nil {
7928 return graphql.Null
7929 }
7930 ctx = graphql.WithFieldContext(ctx, fc)
7931 defer func() {
7932 if r := recover(); r != nil {
7933 ec.Error(ctx, ec.Recover(ctx, r))
7934 ret = graphql.Null
7935 }
7936 }()
7937 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7938 ctx = rctx // use context from middleware stack in children
7939 return obj.Login()
7940 })
7941 if err != nil {
7942 ec.Error(ctx, err)
7943 return graphql.Null
7944 }
7945 if resTmp == nil {
7946 return graphql.Null
7947 }
7948 res := resTmp.(string)
7949 fc.Result = res
7950 return ec.marshalOString2string(ctx, field.Selections, res)
7951}
7952
7953func (ec *executionContext) fieldContext_Identity_login(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7954 fc = &graphql.FieldContext{
7955 Object: "Identity",
7956 Field: field,
7957 IsMethod: true,
7958 IsResolver: false,
7959 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7960 return nil, errors.New("field of type String does not have child fields")
7961 },
7962 }
7963 return fc, nil
7964}
7965
7966func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
7967 fc, err := ec.fieldContext_Identity_displayName(ctx, field)
7968 if err != nil {
7969 return graphql.Null
7970 }
7971 ctx = graphql.WithFieldContext(ctx, fc)
7972 defer func() {
7973 if r := recover(); r != nil {
7974 ec.Error(ctx, ec.Recover(ctx, r))
7975 ret = graphql.Null
7976 }
7977 }()
7978 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7979 ctx = rctx // use context from middleware stack in children
7980 return obj.DisplayName(), nil
7981 })
7982 if err != nil {
7983 ec.Error(ctx, err)
7984 return graphql.Null
7985 }
7986 if resTmp == nil {
7987 if !graphql.HasFieldError(ctx, fc) {
7988 ec.Errorf(ctx, "must not be null")
7989 }
7990 return graphql.Null
7991 }
7992 res := resTmp.(string)
7993 fc.Result = res
7994 return ec.marshalNString2string(ctx, field.Selections, res)
7995}
7996
7997func (ec *executionContext) fieldContext_Identity_displayName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7998 fc = &graphql.FieldContext{
7999 Object: "Identity",
8000 Field: field,
8001 IsMethod: true,
8002 IsResolver: false,
8003 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8004 return nil, errors.New("field of type String does not have child fields")
8005 },
8006 }
8007 return fc, nil
8008}
8009
8010func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
8011 fc, err := ec.fieldContext_Identity_avatarUrl(ctx, field)
8012 if err != nil {
8013 return graphql.Null
8014 }
8015 ctx = graphql.WithFieldContext(ctx, fc)
8016 defer func() {
8017 if r := recover(); r != nil {
8018 ec.Error(ctx, ec.Recover(ctx, r))
8019 ret = graphql.Null
8020 }
8021 }()
8022 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8023 ctx = rctx // use context from middleware stack in children
8024 return obj.AvatarUrl()
8025 })
8026 if err != nil {
8027 ec.Error(ctx, err)
8028 return graphql.Null
8029 }
8030 if resTmp == nil {
8031 return graphql.Null
8032 }
8033 res := resTmp.(string)
8034 fc.Result = res
8035 return ec.marshalOString2string(ctx, field.Selections, res)
8036}
8037
8038func (ec *executionContext) fieldContext_Identity_avatarUrl(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8039 fc = &graphql.FieldContext{
8040 Object: "Identity",
8041 Field: field,
8042 IsMethod: true,
8043 IsResolver: false,
8044 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8045 return nil, errors.New("field of type String does not have child fields")
8046 },
8047 }
8048 return fc, nil
8049}
8050
8051func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
8052 fc, err := ec.fieldContext_Identity_isProtected(ctx, field)
8053 if err != nil {
8054 return graphql.Null
8055 }
8056 ctx = graphql.WithFieldContext(ctx, fc)
8057 defer func() {
8058 if r := recover(); r != nil {
8059 ec.Error(ctx, ec.Recover(ctx, r))
8060 ret = graphql.Null
8061 }
8062 }()
8063 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8064 ctx = rctx // use context from middleware stack in children
8065 return obj.IsProtected()
8066 })
8067 if err != nil {
8068 ec.Error(ctx, err)
8069 return graphql.Null
8070 }
8071 if resTmp == nil {
8072 if !graphql.HasFieldError(ctx, fc) {
8073 ec.Errorf(ctx, "must not be null")
8074 }
8075 return graphql.Null
8076 }
8077 res := resTmp.(bool)
8078 fc.Result = res
8079 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
8080}
8081
8082func (ec *executionContext) fieldContext_Identity_isProtected(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8083 fc = &graphql.FieldContext{
8084 Object: "Identity",
8085 Field: field,
8086 IsMethod: true,
8087 IsResolver: false,
8088 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8089 return nil, errors.New("field of type Boolean does not have child fields")
8090 },
8091 }
8092 return fc, nil
8093}
8094
8095func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
8096 fc, err := ec.fieldContext_IdentityConnection_edges(ctx, field)
8097 if err != nil {
8098 return graphql.Null
8099 }
8100 ctx = graphql.WithFieldContext(ctx, fc)
8101 defer func() {
8102 if r := recover(); r != nil {
8103 ec.Error(ctx, ec.Recover(ctx, r))
8104 ret = graphql.Null
8105 }
8106 }()
8107 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8108 ctx = rctx // use context from middleware stack in children
8109 return obj.Edges, nil
8110 })
8111 if err != nil {
8112 ec.Error(ctx, err)
8113 return graphql.Null
8114 }
8115 if resTmp == nil {
8116 if !graphql.HasFieldError(ctx, fc) {
8117 ec.Errorf(ctx, "must not be null")
8118 }
8119 return graphql.Null
8120 }
8121 res := resTmp.([]*models.IdentityEdge)
8122 fc.Result = res
8123 return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx, field.Selections, res)
8124}
8125
8126func (ec *executionContext) fieldContext_IdentityConnection_edges(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8127 fc = &graphql.FieldContext{
8128 Object: "IdentityConnection",
8129 Field: field,
8130 IsMethod: false,
8131 IsResolver: false,
8132 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8133 switch field.Name {
8134 case "cursor":
8135 return ec.fieldContext_IdentityEdge_cursor(ctx, field)
8136 case "node":
8137 return ec.fieldContext_IdentityEdge_node(ctx, field)
8138 }
8139 return nil, fmt.Errorf("no field named %q was found under type IdentityEdge", field.Name)
8140 },
8141 }
8142 return fc, nil
8143}
8144
8145func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
8146 fc, err := ec.fieldContext_IdentityConnection_nodes(ctx, field)
8147 if err != nil {
8148 return graphql.Null
8149 }
8150 ctx = graphql.WithFieldContext(ctx, fc)
8151 defer func() {
8152 if r := recover(); r != nil {
8153 ec.Error(ctx, ec.Recover(ctx, r))
8154 ret = graphql.Null
8155 }
8156 }()
8157 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8158 ctx = rctx // use context from middleware stack in children
8159 return obj.Nodes, nil
8160 })
8161 if err != nil {
8162 ec.Error(ctx, err)
8163 return graphql.Null
8164 }
8165 if resTmp == nil {
8166 if !graphql.HasFieldError(ctx, fc) {
8167 ec.Errorf(ctx, "must not be null")
8168 }
8169 return graphql.Null
8170 }
8171 res := resTmp.([]models.IdentityWrapper)
8172 fc.Result = res
8173 return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx, field.Selections, res)
8174}
8175
8176func (ec *executionContext) fieldContext_IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8177 fc = &graphql.FieldContext{
8178 Object: "IdentityConnection",
8179 Field: field,
8180 IsMethod: false,
8181 IsResolver: false,
8182 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8183 switch field.Name {
8184 case "id":
8185 return ec.fieldContext_Identity_id(ctx, field)
8186 case "humanId":
8187 return ec.fieldContext_Identity_humanId(ctx, field)
8188 case "name":
8189 return ec.fieldContext_Identity_name(ctx, field)
8190 case "email":
8191 return ec.fieldContext_Identity_email(ctx, field)
8192 case "login":
8193 return ec.fieldContext_Identity_login(ctx, field)
8194 case "displayName":
8195 return ec.fieldContext_Identity_displayName(ctx, field)
8196 case "avatarUrl":
8197 return ec.fieldContext_Identity_avatarUrl(ctx, field)
8198 case "isProtected":
8199 return ec.fieldContext_Identity_isProtected(ctx, field)
8200 }
8201 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
8202 },
8203 }
8204 return fc, nil
8205}
8206
8207func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
8208 fc, err := ec.fieldContext_IdentityConnection_pageInfo(ctx, field)
8209 if err != nil {
8210 return graphql.Null
8211 }
8212 ctx = graphql.WithFieldContext(ctx, fc)
8213 defer func() {
8214 if r := recover(); r != nil {
8215 ec.Error(ctx, ec.Recover(ctx, r))
8216 ret = graphql.Null
8217 }
8218 }()
8219 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8220 ctx = rctx // use context from middleware stack in children
8221 return obj.PageInfo, nil
8222 })
8223 if err != nil {
8224 ec.Error(ctx, err)
8225 return graphql.Null
8226 }
8227 if resTmp == nil {
8228 if !graphql.HasFieldError(ctx, fc) {
8229 ec.Errorf(ctx, "must not be null")
8230 }
8231 return graphql.Null
8232 }
8233 res := resTmp.(*models.PageInfo)
8234 fc.Result = res
8235 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
8236}
8237
8238func (ec *executionContext) fieldContext_IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8239 fc = &graphql.FieldContext{
8240 Object: "IdentityConnection",
8241 Field: field,
8242 IsMethod: false,
8243 IsResolver: false,
8244 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8245 switch field.Name {
8246 case "hasNextPage":
8247 return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
8248 case "hasPreviousPage":
8249 return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
8250 case "startCursor":
8251 return ec.fieldContext_PageInfo_startCursor(ctx, field)
8252 case "endCursor":
8253 return ec.fieldContext_PageInfo_endCursor(ctx, field)
8254 }
8255 return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
8256 },
8257 }
8258 return fc, nil
8259}
8260
8261func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
8262 fc, err := ec.fieldContext_IdentityConnection_totalCount(ctx, field)
8263 if err != nil {
8264 return graphql.Null
8265 }
8266 ctx = graphql.WithFieldContext(ctx, fc)
8267 defer func() {
8268 if r := recover(); r != nil {
8269 ec.Error(ctx, ec.Recover(ctx, r))
8270 ret = graphql.Null
8271 }
8272 }()
8273 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8274 ctx = rctx // use context from middleware stack in children
8275 return obj.TotalCount, nil
8276 })
8277 if err != nil {
8278 ec.Error(ctx, err)
8279 return graphql.Null
8280 }
8281 if resTmp == nil {
8282 if !graphql.HasFieldError(ctx, fc) {
8283 ec.Errorf(ctx, "must not be null")
8284 }
8285 return graphql.Null
8286 }
8287 res := resTmp.(int)
8288 fc.Result = res
8289 return ec.marshalNInt2int(ctx, field.Selections, res)
8290}
8291
8292func (ec *executionContext) fieldContext_IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8293 fc = &graphql.FieldContext{
8294 Object: "IdentityConnection",
8295 Field: field,
8296 IsMethod: false,
8297 IsResolver: false,
8298 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8299 return nil, errors.New("field of type Int does not have child fields")
8300 },
8301 }
8302 return fc, nil
8303}
8304
8305func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
8306 fc, err := ec.fieldContext_IdentityEdge_cursor(ctx, field)
8307 if err != nil {
8308 return graphql.Null
8309 }
8310 ctx = graphql.WithFieldContext(ctx, fc)
8311 defer func() {
8312 if r := recover(); r != nil {
8313 ec.Error(ctx, ec.Recover(ctx, r))
8314 ret = graphql.Null
8315 }
8316 }()
8317 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8318 ctx = rctx // use context from middleware stack in children
8319 return obj.Cursor, nil
8320 })
8321 if err != nil {
8322 ec.Error(ctx, err)
8323 return graphql.Null
8324 }
8325 if resTmp == nil {
8326 if !graphql.HasFieldError(ctx, fc) {
8327 ec.Errorf(ctx, "must not be null")
8328 }
8329 return graphql.Null
8330 }
8331 res := resTmp.(string)
8332 fc.Result = res
8333 return ec.marshalNString2string(ctx, field.Selections, res)
8334}
8335
8336func (ec *executionContext) fieldContext_IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8337 fc = &graphql.FieldContext{
8338 Object: "IdentityEdge",
8339 Field: field,
8340 IsMethod: false,
8341 IsResolver: false,
8342 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8343 return nil, errors.New("field of type String does not have child fields")
8344 },
8345 }
8346 return fc, nil
8347}
8348
8349func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
8350 fc, err := ec.fieldContext_IdentityEdge_node(ctx, field)
8351 if err != nil {
8352 return graphql.Null
8353 }
8354 ctx = graphql.WithFieldContext(ctx, fc)
8355 defer func() {
8356 if r := recover(); r != nil {
8357 ec.Error(ctx, ec.Recover(ctx, r))
8358 ret = graphql.Null
8359 }
8360 }()
8361 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8362 ctx = rctx // use context from middleware stack in children
8363 return obj.Node, nil
8364 })
8365 if err != nil {
8366 ec.Error(ctx, err)
8367 return graphql.Null
8368 }
8369 if resTmp == nil {
8370 if !graphql.HasFieldError(ctx, fc) {
8371 ec.Errorf(ctx, "must not be null")
8372 }
8373 return graphql.Null
8374 }
8375 res := resTmp.(models.IdentityWrapper)
8376 fc.Result = res
8377 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8378}
8379
8380func (ec *executionContext) fieldContext_IdentityEdge_node(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8381 fc = &graphql.FieldContext{
8382 Object: "IdentityEdge",
8383 Field: field,
8384 IsMethod: false,
8385 IsResolver: false,
8386 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8387 switch field.Name {
8388 case "id":
8389 return ec.fieldContext_Identity_id(ctx, field)
8390 case "humanId":
8391 return ec.fieldContext_Identity_humanId(ctx, field)
8392 case "name":
8393 return ec.fieldContext_Identity_name(ctx, field)
8394 case "email":
8395 return ec.fieldContext_Identity_email(ctx, field)
8396 case "login":
8397 return ec.fieldContext_Identity_login(ctx, field)
8398 case "displayName":
8399 return ec.fieldContext_Identity_displayName(ctx, field)
8400 case "avatarUrl":
8401 return ec.fieldContext_Identity_avatarUrl(ctx, field)
8402 case "isProtected":
8403 return ec.fieldContext_Identity_isProtected(ctx, field)
8404 }
8405 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
8406 },
8407 }
8408 return fc, nil
8409}
8410
8411func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
8412 fc, err := ec.fieldContext_Label_name(ctx, field)
8413 if err != nil {
8414 return graphql.Null
8415 }
8416 ctx = graphql.WithFieldContext(ctx, fc)
8417 defer func() {
8418 if r := recover(); r != nil {
8419 ec.Error(ctx, ec.Recover(ctx, r))
8420 ret = graphql.Null
8421 }
8422 }()
8423 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8424 ctx = rctx // use context from middleware stack in children
8425 return ec.resolvers.Label().Name(rctx, obj)
8426 })
8427 if err != nil {
8428 ec.Error(ctx, err)
8429 return graphql.Null
8430 }
8431 if resTmp == nil {
8432 if !graphql.HasFieldError(ctx, fc) {
8433 ec.Errorf(ctx, "must not be null")
8434 }
8435 return graphql.Null
8436 }
8437 res := resTmp.(string)
8438 fc.Result = res
8439 return ec.marshalNString2string(ctx, field.Selections, res)
8440}
8441
8442func (ec *executionContext) fieldContext_Label_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8443 fc = &graphql.FieldContext{
8444 Object: "Label",
8445 Field: field,
8446 IsMethod: true,
8447 IsResolver: true,
8448 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8449 return nil, errors.New("field of type String does not have child fields")
8450 },
8451 }
8452 return fc, nil
8453}
8454
8455func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
8456 fc, err := ec.fieldContext_Label_color(ctx, field)
8457 if err != nil {
8458 return graphql.Null
8459 }
8460 ctx = graphql.WithFieldContext(ctx, fc)
8461 defer func() {
8462 if r := recover(); r != nil {
8463 ec.Error(ctx, ec.Recover(ctx, r))
8464 ret = graphql.Null
8465 }
8466 }()
8467 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8468 ctx = rctx // use context from middleware stack in children
8469 return ec.resolvers.Label().Color(rctx, obj)
8470 })
8471 if err != nil {
8472 ec.Error(ctx, err)
8473 return graphql.Null
8474 }
8475 if resTmp == nil {
8476 if !graphql.HasFieldError(ctx, fc) {
8477 ec.Errorf(ctx, "must not be null")
8478 }
8479 return graphql.Null
8480 }
8481 res := resTmp.(*color.RGBA)
8482 fc.Result = res
8483 return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
8484}
8485
8486func (ec *executionContext) fieldContext_Label_color(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8487 fc = &graphql.FieldContext{
8488 Object: "Label",
8489 Field: field,
8490 IsMethod: true,
8491 IsResolver: true,
8492 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8493 switch field.Name {
8494 case "R":
8495 return ec.fieldContext_Color_R(ctx, field)
8496 case "G":
8497 return ec.fieldContext_Color_G(ctx, field)
8498 case "B":
8499 return ec.fieldContext_Color_B(ctx, field)
8500 }
8501 return nil, fmt.Errorf("no field named %q was found under type Color", field.Name)
8502 },
8503 }
8504 return fc, nil
8505}
8506
8507func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
8508 fc, err := ec.fieldContext_LabelChangeOperation_id(ctx, field)
8509 if err != nil {
8510 return graphql.Null
8511 }
8512 ctx = graphql.WithFieldContext(ctx, fc)
8513 defer func() {
8514 if r := recover(); r != nil {
8515 ec.Error(ctx, ec.Recover(ctx, r))
8516 ret = graphql.Null
8517 }
8518 }()
8519 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8520 ctx = rctx // use context from middleware stack in children
8521 return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
8522 })
8523 if err != nil {
8524 ec.Error(ctx, err)
8525 return graphql.Null
8526 }
8527 if resTmp == nil {
8528 if !graphql.HasFieldError(ctx, fc) {
8529 ec.Errorf(ctx, "must not be null")
8530 }
8531 return graphql.Null
8532 }
8533 res := resTmp.(string)
8534 fc.Result = res
8535 return ec.marshalNString2string(ctx, field.Selections, res)
8536}
8537
8538func (ec *executionContext) fieldContext_LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8539 fc = &graphql.FieldContext{
8540 Object: "LabelChangeOperation",
8541 Field: field,
8542 IsMethod: true,
8543 IsResolver: true,
8544 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8545 return nil, errors.New("field of type String does not have child fields")
8546 },
8547 }
8548 return fc, nil
8549}
8550
8551func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
8552 fc, err := ec.fieldContext_LabelChangeOperation_author(ctx, field)
8553 if err != nil {
8554 return graphql.Null
8555 }
8556 ctx = graphql.WithFieldContext(ctx, fc)
8557 defer func() {
8558 if r := recover(); r != nil {
8559 ec.Error(ctx, ec.Recover(ctx, r))
8560 ret = graphql.Null
8561 }
8562 }()
8563 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8564 ctx = rctx // use context from middleware stack in children
8565 return ec.resolvers.LabelChangeOperation().Author(rctx, obj)
8566 })
8567 if err != nil {
8568 ec.Error(ctx, err)
8569 return graphql.Null
8570 }
8571 if resTmp == nil {
8572 if !graphql.HasFieldError(ctx, fc) {
8573 ec.Errorf(ctx, "must not be null")
8574 }
8575 return graphql.Null
8576 }
8577 res := resTmp.(models.IdentityWrapper)
8578 fc.Result = res
8579 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8580}
8581
8582func (ec *executionContext) fieldContext_LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8583 fc = &graphql.FieldContext{
8584 Object: "LabelChangeOperation",
8585 Field: field,
8586 IsMethod: true,
8587 IsResolver: true,
8588 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8589 switch field.Name {
8590 case "id":
8591 return ec.fieldContext_Identity_id(ctx, field)
8592 case "humanId":
8593 return ec.fieldContext_Identity_humanId(ctx, field)
8594 case "name":
8595 return ec.fieldContext_Identity_name(ctx, field)
8596 case "email":
8597 return ec.fieldContext_Identity_email(ctx, field)
8598 case "login":
8599 return ec.fieldContext_Identity_login(ctx, field)
8600 case "displayName":
8601 return ec.fieldContext_Identity_displayName(ctx, field)
8602 case "avatarUrl":
8603 return ec.fieldContext_Identity_avatarUrl(ctx, field)
8604 case "isProtected":
8605 return ec.fieldContext_Identity_isProtected(ctx, field)
8606 }
8607 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
8608 },
8609 }
8610 return fc, nil
8611}
8612
8613func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
8614 fc, err := ec.fieldContext_LabelChangeOperation_date(ctx, field)
8615 if err != nil {
8616 return graphql.Null
8617 }
8618 ctx = graphql.WithFieldContext(ctx, fc)
8619 defer func() {
8620 if r := recover(); r != nil {
8621 ec.Error(ctx, ec.Recover(ctx, r))
8622 ret = graphql.Null
8623 }
8624 }()
8625 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8626 ctx = rctx // use context from middleware stack in children
8627 return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
8628 })
8629 if err != nil {
8630 ec.Error(ctx, err)
8631 return graphql.Null
8632 }
8633 if resTmp == nil {
8634 if !graphql.HasFieldError(ctx, fc) {
8635 ec.Errorf(ctx, "must not be null")
8636 }
8637 return graphql.Null
8638 }
8639 res := resTmp.(*time.Time)
8640 fc.Result = res
8641 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8642}
8643
8644func (ec *executionContext) fieldContext_LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8645 fc = &graphql.FieldContext{
8646 Object: "LabelChangeOperation",
8647 Field: field,
8648 IsMethod: true,
8649 IsResolver: true,
8650 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8651 return nil, errors.New("field of type Time does not have child fields")
8652 },
8653 }
8654 return fc, nil
8655}
8656
8657func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
8658 fc, err := ec.fieldContext_LabelChangeOperation_added(ctx, field)
8659 if err != nil {
8660 return graphql.Null
8661 }
8662 ctx = graphql.WithFieldContext(ctx, fc)
8663 defer func() {
8664 if r := recover(); r != nil {
8665 ec.Error(ctx, ec.Recover(ctx, r))
8666 ret = graphql.Null
8667 }
8668 }()
8669 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8670 ctx = rctx // use context from middleware stack in children
8671 return obj.Added, nil
8672 })
8673 if err != nil {
8674 ec.Error(ctx, err)
8675 return graphql.Null
8676 }
8677 if resTmp == nil {
8678 if !graphql.HasFieldError(ctx, fc) {
8679 ec.Errorf(ctx, "must not be null")
8680 }
8681 return graphql.Null
8682 }
8683 res := resTmp.([]bug.Label)
8684 fc.Result = res
8685 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
8686}
8687
8688func (ec *executionContext) fieldContext_LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8689 fc = &graphql.FieldContext{
8690 Object: "LabelChangeOperation",
8691 Field: field,
8692 IsMethod: false,
8693 IsResolver: false,
8694 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8695 switch field.Name {
8696 case "name":
8697 return ec.fieldContext_Label_name(ctx, field)
8698 case "color":
8699 return ec.fieldContext_Label_color(ctx, field)
8700 }
8701 return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
8702 },
8703 }
8704 return fc, nil
8705}
8706
8707func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
8708 fc, err := ec.fieldContext_LabelChangeOperation_removed(ctx, field)
8709 if err != nil {
8710 return graphql.Null
8711 }
8712 ctx = graphql.WithFieldContext(ctx, fc)
8713 defer func() {
8714 if r := recover(); r != nil {
8715 ec.Error(ctx, ec.Recover(ctx, r))
8716 ret = graphql.Null
8717 }
8718 }()
8719 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8720 ctx = rctx // use context from middleware stack in children
8721 return obj.Removed, nil
8722 })
8723 if err != nil {
8724 ec.Error(ctx, err)
8725 return graphql.Null
8726 }
8727 if resTmp == nil {
8728 if !graphql.HasFieldError(ctx, fc) {
8729 ec.Errorf(ctx, "must not be null")
8730 }
8731 return graphql.Null
8732 }
8733 res := resTmp.([]bug.Label)
8734 fc.Result = res
8735 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
8736}
8737
8738func (ec *executionContext) fieldContext_LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8739 fc = &graphql.FieldContext{
8740 Object: "LabelChangeOperation",
8741 Field: field,
8742 IsMethod: false,
8743 IsResolver: false,
8744 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8745 switch field.Name {
8746 case "name":
8747 return ec.fieldContext_Label_name(ctx, field)
8748 case "color":
8749 return ec.fieldContext_Label_color(ctx, field)
8750 }
8751 return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
8752 },
8753 }
8754 return fc, nil
8755}
8756
8757func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
8758 fc, err := ec.fieldContext_LabelChangeResult_label(ctx, field)
8759 if err != nil {
8760 return graphql.Null
8761 }
8762 ctx = graphql.WithFieldContext(ctx, fc)
8763 defer func() {
8764 if r := recover(); r != nil {
8765 ec.Error(ctx, ec.Recover(ctx, r))
8766 ret = graphql.Null
8767 }
8768 }()
8769 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8770 ctx = rctx // use context from middleware stack in children
8771 return obj.Label, nil
8772 })
8773 if err != nil {
8774 ec.Error(ctx, err)
8775 return graphql.Null
8776 }
8777 if resTmp == nil {
8778 if !graphql.HasFieldError(ctx, fc) {
8779 ec.Errorf(ctx, "must not be null")
8780 }
8781 return graphql.Null
8782 }
8783 res := resTmp.(bug.Label)
8784 fc.Result = res
8785 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
8786}
8787
8788func (ec *executionContext) fieldContext_LabelChangeResult_label(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8789 fc = &graphql.FieldContext{
8790 Object: "LabelChangeResult",
8791 Field: field,
8792 IsMethod: false,
8793 IsResolver: false,
8794 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8795 switch field.Name {
8796 case "name":
8797 return ec.fieldContext_Label_name(ctx, field)
8798 case "color":
8799 return ec.fieldContext_Label_color(ctx, field)
8800 }
8801 return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
8802 },
8803 }
8804 return fc, nil
8805}
8806
8807func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
8808 fc, err := ec.fieldContext_LabelChangeResult_status(ctx, field)
8809 if err != nil {
8810 return graphql.Null
8811 }
8812 ctx = graphql.WithFieldContext(ctx, fc)
8813 defer func() {
8814 if r := recover(); r != nil {
8815 ec.Error(ctx, ec.Recover(ctx, r))
8816 ret = graphql.Null
8817 }
8818 }()
8819 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8820 ctx = rctx // use context from middleware stack in children
8821 return ec.resolvers.LabelChangeResult().Status(rctx, obj)
8822 })
8823 if err != nil {
8824 ec.Error(ctx, err)
8825 return graphql.Null
8826 }
8827 if resTmp == nil {
8828 if !graphql.HasFieldError(ctx, fc) {
8829 ec.Errorf(ctx, "must not be null")
8830 }
8831 return graphql.Null
8832 }
8833 res := resTmp.(models.LabelChangeStatus)
8834 fc.Result = res
8835 return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
8836}
8837
8838func (ec *executionContext) fieldContext_LabelChangeResult_status(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8839 fc = &graphql.FieldContext{
8840 Object: "LabelChangeResult",
8841 Field: field,
8842 IsMethod: true,
8843 IsResolver: true,
8844 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8845 return nil, errors.New("field of type LabelChangeStatus does not have child fields")
8846 },
8847 }
8848 return fc, nil
8849}
8850
8851func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
8852 fc, err := ec.fieldContext_LabelChangeTimelineItem_id(ctx, field)
8853 if err != nil {
8854 return graphql.Null
8855 }
8856 ctx = graphql.WithFieldContext(ctx, fc)
8857 defer func() {
8858 if r := recover(); r != nil {
8859 ec.Error(ctx, ec.Recover(ctx, r))
8860 ret = graphql.Null
8861 }
8862 }()
8863 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8864 ctx = rctx // use context from middleware stack in children
8865 return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
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.(string)
8878 fc.Result = res
8879 return ec.marshalNString2string(ctx, field.Selections, res)
8880}
8881
8882func (ec *executionContext) fieldContext_LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8883 fc = &graphql.FieldContext{
8884 Object: "LabelChangeTimelineItem",
8885 Field: field,
8886 IsMethod: true,
8887 IsResolver: true,
8888 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8889 return nil, errors.New("field of type String does not have child fields")
8890 },
8891 }
8892 return fc, nil
8893}
8894
8895func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
8896 fc, err := ec.fieldContext_LabelChangeTimelineItem_author(ctx, field)
8897 if err != nil {
8898 return graphql.Null
8899 }
8900 ctx = graphql.WithFieldContext(ctx, fc)
8901 defer func() {
8902 if r := recover(); r != nil {
8903 ec.Error(ctx, ec.Recover(ctx, r))
8904 ret = graphql.Null
8905 }
8906 }()
8907 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8908 ctx = rctx // use context from middleware stack in children
8909 return ec.resolvers.LabelChangeTimelineItem().Author(rctx, obj)
8910 })
8911 if err != nil {
8912 ec.Error(ctx, err)
8913 return graphql.Null
8914 }
8915 if resTmp == nil {
8916 if !graphql.HasFieldError(ctx, fc) {
8917 ec.Errorf(ctx, "must not be null")
8918 }
8919 return graphql.Null
8920 }
8921 res := resTmp.(models.IdentityWrapper)
8922 fc.Result = res
8923 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8924}
8925
8926func (ec *executionContext) fieldContext_LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8927 fc = &graphql.FieldContext{
8928 Object: "LabelChangeTimelineItem",
8929 Field: field,
8930 IsMethod: true,
8931 IsResolver: true,
8932 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8933 switch field.Name {
8934 case "id":
8935 return ec.fieldContext_Identity_id(ctx, field)
8936 case "humanId":
8937 return ec.fieldContext_Identity_humanId(ctx, field)
8938 case "name":
8939 return ec.fieldContext_Identity_name(ctx, field)
8940 case "email":
8941 return ec.fieldContext_Identity_email(ctx, field)
8942 case "login":
8943 return ec.fieldContext_Identity_login(ctx, field)
8944 case "displayName":
8945 return ec.fieldContext_Identity_displayName(ctx, field)
8946 case "avatarUrl":
8947 return ec.fieldContext_Identity_avatarUrl(ctx, field)
8948 case "isProtected":
8949 return ec.fieldContext_Identity_isProtected(ctx, field)
8950 }
8951 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
8952 },
8953 }
8954 return fc, nil
8955}
8956
8957func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
8958 fc, err := ec.fieldContext_LabelChangeTimelineItem_date(ctx, field)
8959 if err != nil {
8960 return graphql.Null
8961 }
8962 ctx = graphql.WithFieldContext(ctx, fc)
8963 defer func() {
8964 if r := recover(); r != nil {
8965 ec.Error(ctx, ec.Recover(ctx, r))
8966 ret = graphql.Null
8967 }
8968 }()
8969 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8970 ctx = rctx // use context from middleware stack in children
8971 return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
8972 })
8973 if err != nil {
8974 ec.Error(ctx, err)
8975 return graphql.Null
8976 }
8977 if resTmp == nil {
8978 if !graphql.HasFieldError(ctx, fc) {
8979 ec.Errorf(ctx, "must not be null")
8980 }
8981 return graphql.Null
8982 }
8983 res := resTmp.(*time.Time)
8984 fc.Result = res
8985 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8986}
8987
8988func (ec *executionContext) fieldContext_LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8989 fc = &graphql.FieldContext{
8990 Object: "LabelChangeTimelineItem",
8991 Field: field,
8992 IsMethod: true,
8993 IsResolver: true,
8994 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8995 return nil, errors.New("field of type Time does not have child fields")
8996 },
8997 }
8998 return fc, nil
8999}
9000
9001func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
9002 fc, err := ec.fieldContext_LabelChangeTimelineItem_added(ctx, field)
9003 if err != nil {
9004 return graphql.Null
9005 }
9006 ctx = graphql.WithFieldContext(ctx, fc)
9007 defer func() {
9008 if r := recover(); r != nil {
9009 ec.Error(ctx, ec.Recover(ctx, r))
9010 ret = graphql.Null
9011 }
9012 }()
9013 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9014 ctx = rctx // use context from middleware stack in children
9015 return obj.Added, nil
9016 })
9017 if err != nil {
9018 ec.Error(ctx, err)
9019 return graphql.Null
9020 }
9021 if resTmp == nil {
9022 if !graphql.HasFieldError(ctx, fc) {
9023 ec.Errorf(ctx, "must not be null")
9024 }
9025 return graphql.Null
9026 }
9027 res := resTmp.([]bug.Label)
9028 fc.Result = res
9029 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
9030}
9031
9032func (ec *executionContext) fieldContext_LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9033 fc = &graphql.FieldContext{
9034 Object: "LabelChangeTimelineItem",
9035 Field: field,
9036 IsMethod: false,
9037 IsResolver: false,
9038 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9039 switch field.Name {
9040 case "name":
9041 return ec.fieldContext_Label_name(ctx, field)
9042 case "color":
9043 return ec.fieldContext_Label_color(ctx, field)
9044 }
9045 return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
9046 },
9047 }
9048 return fc, nil
9049}
9050
9051func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
9052 fc, err := ec.fieldContext_LabelChangeTimelineItem_removed(ctx, field)
9053 if err != nil {
9054 return graphql.Null
9055 }
9056 ctx = graphql.WithFieldContext(ctx, fc)
9057 defer func() {
9058 if r := recover(); r != nil {
9059 ec.Error(ctx, ec.Recover(ctx, r))
9060 ret = graphql.Null
9061 }
9062 }()
9063 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9064 ctx = rctx // use context from middleware stack in children
9065 return obj.Removed, nil
9066 })
9067 if err != nil {
9068 ec.Error(ctx, err)
9069 return graphql.Null
9070 }
9071 if resTmp == nil {
9072 if !graphql.HasFieldError(ctx, fc) {
9073 ec.Errorf(ctx, "must not be null")
9074 }
9075 return graphql.Null
9076 }
9077 res := resTmp.([]bug.Label)
9078 fc.Result = res
9079 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
9080}
9081
9082func (ec *executionContext) fieldContext_LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9083 fc = &graphql.FieldContext{
9084 Object: "LabelChangeTimelineItem",
9085 Field: field,
9086 IsMethod: false,
9087 IsResolver: false,
9088 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9089 switch field.Name {
9090 case "name":
9091 return ec.fieldContext_Label_name(ctx, field)
9092 case "color":
9093 return ec.fieldContext_Label_color(ctx, field)
9094 }
9095 return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
9096 },
9097 }
9098 return fc, nil
9099}
9100
9101func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
9102 fc, err := ec.fieldContext_LabelConnection_edges(ctx, field)
9103 if err != nil {
9104 return graphql.Null
9105 }
9106 ctx = graphql.WithFieldContext(ctx, fc)
9107 defer func() {
9108 if r := recover(); r != nil {
9109 ec.Error(ctx, ec.Recover(ctx, r))
9110 ret = graphql.Null
9111 }
9112 }()
9113 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9114 ctx = rctx // use context from middleware stack in children
9115 return obj.Edges, nil
9116 })
9117 if err != nil {
9118 ec.Error(ctx, err)
9119 return graphql.Null
9120 }
9121 if resTmp == nil {
9122 if !graphql.HasFieldError(ctx, fc) {
9123 ec.Errorf(ctx, "must not be null")
9124 }
9125 return graphql.Null
9126 }
9127 res := resTmp.([]*models.LabelEdge)
9128 fc.Result = res
9129 return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx, field.Selections, res)
9130}
9131
9132func (ec *executionContext) fieldContext_LabelConnection_edges(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9133 fc = &graphql.FieldContext{
9134 Object: "LabelConnection",
9135 Field: field,
9136 IsMethod: false,
9137 IsResolver: false,
9138 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9139 switch field.Name {
9140 case "cursor":
9141 return ec.fieldContext_LabelEdge_cursor(ctx, field)
9142 case "node":
9143 return ec.fieldContext_LabelEdge_node(ctx, field)
9144 }
9145 return nil, fmt.Errorf("no field named %q was found under type LabelEdge", field.Name)
9146 },
9147 }
9148 return fc, nil
9149}
9150
9151func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
9152 fc, err := ec.fieldContext_LabelConnection_nodes(ctx, field)
9153 if err != nil {
9154 return graphql.Null
9155 }
9156 ctx = graphql.WithFieldContext(ctx, fc)
9157 defer func() {
9158 if r := recover(); r != nil {
9159 ec.Error(ctx, ec.Recover(ctx, r))
9160 ret = graphql.Null
9161 }
9162 }()
9163 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9164 ctx = rctx // use context from middleware stack in children
9165 return obj.Nodes, nil
9166 })
9167 if err != nil {
9168 ec.Error(ctx, err)
9169 return graphql.Null
9170 }
9171 if resTmp == nil {
9172 if !graphql.HasFieldError(ctx, fc) {
9173 ec.Errorf(ctx, "must not be null")
9174 }
9175 return graphql.Null
9176 }
9177 res := resTmp.([]bug.Label)
9178 fc.Result = res
9179 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
9180}
9181
9182func (ec *executionContext) fieldContext_LabelConnection_nodes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9183 fc = &graphql.FieldContext{
9184 Object: "LabelConnection",
9185 Field: field,
9186 IsMethod: false,
9187 IsResolver: false,
9188 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9189 switch field.Name {
9190 case "name":
9191 return ec.fieldContext_Label_name(ctx, field)
9192 case "color":
9193 return ec.fieldContext_Label_color(ctx, field)
9194 }
9195 return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
9196 },
9197 }
9198 return fc, nil
9199}
9200
9201func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
9202 fc, err := ec.fieldContext_LabelConnection_pageInfo(ctx, field)
9203 if err != nil {
9204 return graphql.Null
9205 }
9206 ctx = graphql.WithFieldContext(ctx, fc)
9207 defer func() {
9208 if r := recover(); r != nil {
9209 ec.Error(ctx, ec.Recover(ctx, r))
9210 ret = graphql.Null
9211 }
9212 }()
9213 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9214 ctx = rctx // use context from middleware stack in children
9215 return obj.PageInfo, nil
9216 })
9217 if err != nil {
9218 ec.Error(ctx, err)
9219 return graphql.Null
9220 }
9221 if resTmp == nil {
9222 if !graphql.HasFieldError(ctx, fc) {
9223 ec.Errorf(ctx, "must not be null")
9224 }
9225 return graphql.Null
9226 }
9227 res := resTmp.(*models.PageInfo)
9228 fc.Result = res
9229 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
9230}
9231
9232func (ec *executionContext) fieldContext_LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9233 fc = &graphql.FieldContext{
9234 Object: "LabelConnection",
9235 Field: field,
9236 IsMethod: false,
9237 IsResolver: false,
9238 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9239 switch field.Name {
9240 case "hasNextPage":
9241 return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
9242 case "hasPreviousPage":
9243 return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
9244 case "startCursor":
9245 return ec.fieldContext_PageInfo_startCursor(ctx, field)
9246 case "endCursor":
9247 return ec.fieldContext_PageInfo_endCursor(ctx, field)
9248 }
9249 return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
9250 },
9251 }
9252 return fc, nil
9253}
9254
9255func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
9256 fc, err := ec.fieldContext_LabelConnection_totalCount(ctx, field)
9257 if err != nil {
9258 return graphql.Null
9259 }
9260 ctx = graphql.WithFieldContext(ctx, fc)
9261 defer func() {
9262 if r := recover(); r != nil {
9263 ec.Error(ctx, ec.Recover(ctx, r))
9264 ret = graphql.Null
9265 }
9266 }()
9267 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9268 ctx = rctx // use context from middleware stack in children
9269 return obj.TotalCount, nil
9270 })
9271 if err != nil {
9272 ec.Error(ctx, err)
9273 return graphql.Null
9274 }
9275 if resTmp == nil {
9276 if !graphql.HasFieldError(ctx, fc) {
9277 ec.Errorf(ctx, "must not be null")
9278 }
9279 return graphql.Null
9280 }
9281 res := resTmp.(int)
9282 fc.Result = res
9283 return ec.marshalNInt2int(ctx, field.Selections, res)
9284}
9285
9286func (ec *executionContext) fieldContext_LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9287 fc = &graphql.FieldContext{
9288 Object: "LabelConnection",
9289 Field: field,
9290 IsMethod: false,
9291 IsResolver: false,
9292 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9293 return nil, errors.New("field of type Int does not have child fields")
9294 },
9295 }
9296 return fc, nil
9297}
9298
9299func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
9300 fc, err := ec.fieldContext_LabelEdge_cursor(ctx, field)
9301 if err != nil {
9302 return graphql.Null
9303 }
9304 ctx = graphql.WithFieldContext(ctx, fc)
9305 defer func() {
9306 if r := recover(); r != nil {
9307 ec.Error(ctx, ec.Recover(ctx, r))
9308 ret = graphql.Null
9309 }
9310 }()
9311 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9312 ctx = rctx // use context from middleware stack in children
9313 return obj.Cursor, nil
9314 })
9315 if err != nil {
9316 ec.Error(ctx, err)
9317 return graphql.Null
9318 }
9319 if resTmp == nil {
9320 if !graphql.HasFieldError(ctx, fc) {
9321 ec.Errorf(ctx, "must not be null")
9322 }
9323 return graphql.Null
9324 }
9325 res := resTmp.(string)
9326 fc.Result = res
9327 return ec.marshalNString2string(ctx, field.Selections, res)
9328}
9329
9330func (ec *executionContext) fieldContext_LabelEdge_cursor(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9331 fc = &graphql.FieldContext{
9332 Object: "LabelEdge",
9333 Field: field,
9334 IsMethod: false,
9335 IsResolver: false,
9336 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9337 return nil, errors.New("field of type String does not have child fields")
9338 },
9339 }
9340 return fc, nil
9341}
9342
9343func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
9344 fc, err := ec.fieldContext_LabelEdge_node(ctx, field)
9345 if err != nil {
9346 return graphql.Null
9347 }
9348 ctx = graphql.WithFieldContext(ctx, fc)
9349 defer func() {
9350 if r := recover(); r != nil {
9351 ec.Error(ctx, ec.Recover(ctx, r))
9352 ret = graphql.Null
9353 }
9354 }()
9355 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9356 ctx = rctx // use context from middleware stack in children
9357 return obj.Node, nil
9358 })
9359 if err != nil {
9360 ec.Error(ctx, err)
9361 return graphql.Null
9362 }
9363 if resTmp == nil {
9364 if !graphql.HasFieldError(ctx, fc) {
9365 ec.Errorf(ctx, "must not be null")
9366 }
9367 return graphql.Null
9368 }
9369 res := resTmp.(bug.Label)
9370 fc.Result = res
9371 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
9372}
9373
9374func (ec *executionContext) fieldContext_LabelEdge_node(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9375 fc = &graphql.FieldContext{
9376 Object: "LabelEdge",
9377 Field: field,
9378 IsMethod: false,
9379 IsResolver: false,
9380 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9381 switch field.Name {
9382 case "name":
9383 return ec.fieldContext_Label_name(ctx, field)
9384 case "color":
9385 return ec.fieldContext_Label_color(ctx, field)
9386 }
9387 return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
9388 },
9389 }
9390 return fc, nil
9391}
9392
9393func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9394 fc, err := ec.fieldContext_Mutation_newBug(ctx, field)
9395 if err != nil {
9396 return graphql.Null
9397 }
9398 ctx = graphql.WithFieldContext(ctx, fc)
9399 defer func() {
9400 if r := recover(); r != nil {
9401 ec.Error(ctx, ec.Recover(ctx, r))
9402 ret = graphql.Null
9403 }
9404 }()
9405 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9406 ctx = rctx // use context from middleware stack in children
9407 return ec.resolvers.Mutation().NewBug(rctx, fc.Args["input"].(models.NewBugInput))
9408 })
9409 if err != nil {
9410 ec.Error(ctx, err)
9411 return graphql.Null
9412 }
9413 if resTmp == nil {
9414 if !graphql.HasFieldError(ctx, fc) {
9415 ec.Errorf(ctx, "must not be null")
9416 }
9417 return graphql.Null
9418 }
9419 res := resTmp.(*models.NewBugPayload)
9420 fc.Result = res
9421 return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
9422}
9423
9424func (ec *executionContext) fieldContext_Mutation_newBug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9425 fc = &graphql.FieldContext{
9426 Object: "Mutation",
9427 Field: field,
9428 IsMethod: true,
9429 IsResolver: true,
9430 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9431 switch field.Name {
9432 case "clientMutationId":
9433 return ec.fieldContext_NewBugPayload_clientMutationId(ctx, field)
9434 case "bug":
9435 return ec.fieldContext_NewBugPayload_bug(ctx, field)
9436 case "operation":
9437 return ec.fieldContext_NewBugPayload_operation(ctx, field)
9438 }
9439 return nil, fmt.Errorf("no field named %q was found under type NewBugPayload", field.Name)
9440 },
9441 }
9442 defer func() {
9443 if r := recover(); r != nil {
9444 err = ec.Recover(ctx, r)
9445 ec.Error(ctx, err)
9446 }
9447 }()
9448 ctx = graphql.WithFieldContext(ctx, fc)
9449 if fc.Args, err = ec.field_Mutation_newBug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9450 ec.Error(ctx, err)
9451 return
9452 }
9453 return fc, nil
9454}
9455
9456func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9457 fc, err := ec.fieldContext_Mutation_addComment(ctx, field)
9458 if err != nil {
9459 return graphql.Null
9460 }
9461 ctx = graphql.WithFieldContext(ctx, fc)
9462 defer func() {
9463 if r := recover(); r != nil {
9464 ec.Error(ctx, ec.Recover(ctx, r))
9465 ret = graphql.Null
9466 }
9467 }()
9468 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9469 ctx = rctx // use context from middleware stack in children
9470 return ec.resolvers.Mutation().AddComment(rctx, fc.Args["input"].(models.AddCommentInput))
9471 })
9472 if err != nil {
9473 ec.Error(ctx, err)
9474 return graphql.Null
9475 }
9476 if resTmp == nil {
9477 if !graphql.HasFieldError(ctx, fc) {
9478 ec.Errorf(ctx, "must not be null")
9479 }
9480 return graphql.Null
9481 }
9482 res := resTmp.(*models.AddCommentPayload)
9483 fc.Result = res
9484 return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
9485}
9486
9487func (ec *executionContext) fieldContext_Mutation_addComment(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9488 fc = &graphql.FieldContext{
9489 Object: "Mutation",
9490 Field: field,
9491 IsMethod: true,
9492 IsResolver: true,
9493 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9494 switch field.Name {
9495 case "clientMutationId":
9496 return ec.fieldContext_AddCommentPayload_clientMutationId(ctx, field)
9497 case "bug":
9498 return ec.fieldContext_AddCommentPayload_bug(ctx, field)
9499 case "operation":
9500 return ec.fieldContext_AddCommentPayload_operation(ctx, field)
9501 }
9502 return nil, fmt.Errorf("no field named %q was found under type AddCommentPayload", field.Name)
9503 },
9504 }
9505 defer func() {
9506 if r := recover(); r != nil {
9507 err = ec.Recover(ctx, r)
9508 ec.Error(ctx, err)
9509 }
9510 }()
9511 ctx = graphql.WithFieldContext(ctx, fc)
9512 if fc.Args, err = ec.field_Mutation_addComment_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9513 ec.Error(ctx, err)
9514 return
9515 }
9516 return fc, nil
9517}
9518
9519func (ec *executionContext) _Mutation_addCommentAndClose(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9520 fc, err := ec.fieldContext_Mutation_addCommentAndClose(ctx, field)
9521 if err != nil {
9522 return graphql.Null
9523 }
9524 ctx = graphql.WithFieldContext(ctx, fc)
9525 defer func() {
9526 if r := recover(); r != nil {
9527 ec.Error(ctx, ec.Recover(ctx, r))
9528 ret = graphql.Null
9529 }
9530 }()
9531 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9532 ctx = rctx // use context from middleware stack in children
9533 return ec.resolvers.Mutation().AddCommentAndClose(rctx, fc.Args["input"].(models.AddCommentAndCloseBugInput))
9534 })
9535 if err != nil {
9536 ec.Error(ctx, err)
9537 return graphql.Null
9538 }
9539 if resTmp == nil {
9540 if !graphql.HasFieldError(ctx, fc) {
9541 ec.Errorf(ctx, "must not be null")
9542 }
9543 return graphql.Null
9544 }
9545 res := resTmp.(*models.AddCommentAndCloseBugPayload)
9546 fc.Result = res
9547 return ec.marshalNAddCommentAndCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx, field.Selections, res)
9548}
9549
9550func (ec *executionContext) fieldContext_Mutation_addCommentAndClose(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9551 fc = &graphql.FieldContext{
9552 Object: "Mutation",
9553 Field: field,
9554 IsMethod: true,
9555 IsResolver: true,
9556 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9557 switch field.Name {
9558 case "clientMutationId":
9559 return ec.fieldContext_AddCommentAndCloseBugPayload_clientMutationId(ctx, field)
9560 case "bug":
9561 return ec.fieldContext_AddCommentAndCloseBugPayload_bug(ctx, field)
9562 case "commentOperation":
9563 return ec.fieldContext_AddCommentAndCloseBugPayload_commentOperation(ctx, field)
9564 case "statusOperation":
9565 return ec.fieldContext_AddCommentAndCloseBugPayload_statusOperation(ctx, field)
9566 }
9567 return nil, fmt.Errorf("no field named %q was found under type AddCommentAndCloseBugPayload", field.Name)
9568 },
9569 }
9570 defer func() {
9571 if r := recover(); r != nil {
9572 err = ec.Recover(ctx, r)
9573 ec.Error(ctx, err)
9574 }
9575 }()
9576 ctx = graphql.WithFieldContext(ctx, fc)
9577 if fc.Args, err = ec.field_Mutation_addCommentAndClose_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9578 ec.Error(ctx, err)
9579 return
9580 }
9581 return fc, nil
9582}
9583
9584func (ec *executionContext) _Mutation_addCommentAndReopen(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9585 fc, err := ec.fieldContext_Mutation_addCommentAndReopen(ctx, field)
9586 if err != nil {
9587 return graphql.Null
9588 }
9589 ctx = graphql.WithFieldContext(ctx, fc)
9590 defer func() {
9591 if r := recover(); r != nil {
9592 ec.Error(ctx, ec.Recover(ctx, r))
9593 ret = graphql.Null
9594 }
9595 }()
9596 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9597 ctx = rctx // use context from middleware stack in children
9598 return ec.resolvers.Mutation().AddCommentAndReopen(rctx, fc.Args["input"].(models.AddCommentAndReopenBugInput))
9599 })
9600 if err != nil {
9601 ec.Error(ctx, err)
9602 return graphql.Null
9603 }
9604 if resTmp == nil {
9605 if !graphql.HasFieldError(ctx, fc) {
9606 ec.Errorf(ctx, "must not be null")
9607 }
9608 return graphql.Null
9609 }
9610 res := resTmp.(*models.AddCommentAndReopenBugPayload)
9611 fc.Result = res
9612 return ec.marshalNAddCommentAndReopenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx, field.Selections, res)
9613}
9614
9615func (ec *executionContext) fieldContext_Mutation_addCommentAndReopen(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9616 fc = &graphql.FieldContext{
9617 Object: "Mutation",
9618 Field: field,
9619 IsMethod: true,
9620 IsResolver: true,
9621 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9622 switch field.Name {
9623 case "clientMutationId":
9624 return ec.fieldContext_AddCommentAndReopenBugPayload_clientMutationId(ctx, field)
9625 case "bug":
9626 return ec.fieldContext_AddCommentAndReopenBugPayload_bug(ctx, field)
9627 case "commentOperation":
9628 return ec.fieldContext_AddCommentAndReopenBugPayload_commentOperation(ctx, field)
9629 case "statusOperation":
9630 return ec.fieldContext_AddCommentAndReopenBugPayload_statusOperation(ctx, field)
9631 }
9632 return nil, fmt.Errorf("no field named %q was found under type AddCommentAndReopenBugPayload", field.Name)
9633 },
9634 }
9635 defer func() {
9636 if r := recover(); r != nil {
9637 err = ec.Recover(ctx, r)
9638 ec.Error(ctx, err)
9639 }
9640 }()
9641 ctx = graphql.WithFieldContext(ctx, fc)
9642 if fc.Args, err = ec.field_Mutation_addCommentAndReopen_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9643 ec.Error(ctx, err)
9644 return
9645 }
9646 return fc, nil
9647}
9648
9649func (ec *executionContext) _Mutation_editComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9650 fc, err := ec.fieldContext_Mutation_editComment(ctx, field)
9651 if err != nil {
9652 return graphql.Null
9653 }
9654 ctx = graphql.WithFieldContext(ctx, fc)
9655 defer func() {
9656 if r := recover(); r != nil {
9657 ec.Error(ctx, ec.Recover(ctx, r))
9658 ret = graphql.Null
9659 }
9660 }()
9661 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9662 ctx = rctx // use context from middleware stack in children
9663 return ec.resolvers.Mutation().EditComment(rctx, fc.Args["input"].(models.EditCommentInput))
9664 })
9665 if err != nil {
9666 ec.Error(ctx, err)
9667 return graphql.Null
9668 }
9669 if resTmp == nil {
9670 if !graphql.HasFieldError(ctx, fc) {
9671 ec.Errorf(ctx, "must not be null")
9672 }
9673 return graphql.Null
9674 }
9675 res := resTmp.(*models.EditCommentPayload)
9676 fc.Result = res
9677 return ec.marshalNEditCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx, field.Selections, res)
9678}
9679
9680func (ec *executionContext) fieldContext_Mutation_editComment(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9681 fc = &graphql.FieldContext{
9682 Object: "Mutation",
9683 Field: field,
9684 IsMethod: true,
9685 IsResolver: true,
9686 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9687 switch field.Name {
9688 case "clientMutationId":
9689 return ec.fieldContext_EditCommentPayload_clientMutationId(ctx, field)
9690 case "bug":
9691 return ec.fieldContext_EditCommentPayload_bug(ctx, field)
9692 case "operation":
9693 return ec.fieldContext_EditCommentPayload_operation(ctx, field)
9694 }
9695 return nil, fmt.Errorf("no field named %q was found under type EditCommentPayload", field.Name)
9696 },
9697 }
9698 defer func() {
9699 if r := recover(); r != nil {
9700 err = ec.Recover(ctx, r)
9701 ec.Error(ctx, err)
9702 }
9703 }()
9704 ctx = graphql.WithFieldContext(ctx, fc)
9705 if fc.Args, err = ec.field_Mutation_editComment_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9706 ec.Error(ctx, err)
9707 return
9708 }
9709 return fc, nil
9710}
9711
9712func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9713 fc, err := ec.fieldContext_Mutation_changeLabels(ctx, field)
9714 if err != nil {
9715 return graphql.Null
9716 }
9717 ctx = graphql.WithFieldContext(ctx, fc)
9718 defer func() {
9719 if r := recover(); r != nil {
9720 ec.Error(ctx, ec.Recover(ctx, r))
9721 ret = graphql.Null
9722 }
9723 }()
9724 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9725 ctx = rctx // use context from middleware stack in children
9726 return ec.resolvers.Mutation().ChangeLabels(rctx, fc.Args["input"].(*models.ChangeLabelInput))
9727 })
9728 if err != nil {
9729 ec.Error(ctx, err)
9730 return graphql.Null
9731 }
9732 if resTmp == nil {
9733 if !graphql.HasFieldError(ctx, fc) {
9734 ec.Errorf(ctx, "must not be null")
9735 }
9736 return graphql.Null
9737 }
9738 res := resTmp.(*models.ChangeLabelPayload)
9739 fc.Result = res
9740 return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
9741}
9742
9743func (ec *executionContext) fieldContext_Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9744 fc = &graphql.FieldContext{
9745 Object: "Mutation",
9746 Field: field,
9747 IsMethod: true,
9748 IsResolver: true,
9749 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9750 switch field.Name {
9751 case "clientMutationId":
9752 return ec.fieldContext_ChangeLabelPayload_clientMutationId(ctx, field)
9753 case "bug":
9754 return ec.fieldContext_ChangeLabelPayload_bug(ctx, field)
9755 case "operation":
9756 return ec.fieldContext_ChangeLabelPayload_operation(ctx, field)
9757 case "results":
9758 return ec.fieldContext_ChangeLabelPayload_results(ctx, field)
9759 }
9760 return nil, fmt.Errorf("no field named %q was found under type ChangeLabelPayload", field.Name)
9761 },
9762 }
9763 defer func() {
9764 if r := recover(); r != nil {
9765 err = ec.Recover(ctx, r)
9766 ec.Error(ctx, err)
9767 }
9768 }()
9769 ctx = graphql.WithFieldContext(ctx, fc)
9770 if fc.Args, err = ec.field_Mutation_changeLabels_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9771 ec.Error(ctx, err)
9772 return
9773 }
9774 return fc, nil
9775}
9776
9777func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9778 fc, err := ec.fieldContext_Mutation_openBug(ctx, field)
9779 if err != nil {
9780 return graphql.Null
9781 }
9782 ctx = graphql.WithFieldContext(ctx, fc)
9783 defer func() {
9784 if r := recover(); r != nil {
9785 ec.Error(ctx, ec.Recover(ctx, r))
9786 ret = graphql.Null
9787 }
9788 }()
9789 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9790 ctx = rctx // use context from middleware stack in children
9791 return ec.resolvers.Mutation().OpenBug(rctx, fc.Args["input"].(models.OpenBugInput))
9792 })
9793 if err != nil {
9794 ec.Error(ctx, err)
9795 return graphql.Null
9796 }
9797 if resTmp == nil {
9798 if !graphql.HasFieldError(ctx, fc) {
9799 ec.Errorf(ctx, "must not be null")
9800 }
9801 return graphql.Null
9802 }
9803 res := resTmp.(*models.OpenBugPayload)
9804 fc.Result = res
9805 return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
9806}
9807
9808func (ec *executionContext) fieldContext_Mutation_openBug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9809 fc = &graphql.FieldContext{
9810 Object: "Mutation",
9811 Field: field,
9812 IsMethod: true,
9813 IsResolver: true,
9814 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9815 switch field.Name {
9816 case "clientMutationId":
9817 return ec.fieldContext_OpenBugPayload_clientMutationId(ctx, field)
9818 case "bug":
9819 return ec.fieldContext_OpenBugPayload_bug(ctx, field)
9820 case "operation":
9821 return ec.fieldContext_OpenBugPayload_operation(ctx, field)
9822 }
9823 return nil, fmt.Errorf("no field named %q was found under type OpenBugPayload", field.Name)
9824 },
9825 }
9826 defer func() {
9827 if r := recover(); r != nil {
9828 err = ec.Recover(ctx, r)
9829 ec.Error(ctx, err)
9830 }
9831 }()
9832 ctx = graphql.WithFieldContext(ctx, fc)
9833 if fc.Args, err = ec.field_Mutation_openBug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9834 ec.Error(ctx, err)
9835 return
9836 }
9837 return fc, nil
9838}
9839
9840func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9841 fc, err := ec.fieldContext_Mutation_closeBug(ctx, field)
9842 if err != nil {
9843 return graphql.Null
9844 }
9845 ctx = graphql.WithFieldContext(ctx, fc)
9846 defer func() {
9847 if r := recover(); r != nil {
9848 ec.Error(ctx, ec.Recover(ctx, r))
9849 ret = graphql.Null
9850 }
9851 }()
9852 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9853 ctx = rctx // use context from middleware stack in children
9854 return ec.resolvers.Mutation().CloseBug(rctx, fc.Args["input"].(models.CloseBugInput))
9855 })
9856 if err != nil {
9857 ec.Error(ctx, err)
9858 return graphql.Null
9859 }
9860 if resTmp == nil {
9861 if !graphql.HasFieldError(ctx, fc) {
9862 ec.Errorf(ctx, "must not be null")
9863 }
9864 return graphql.Null
9865 }
9866 res := resTmp.(*models.CloseBugPayload)
9867 fc.Result = res
9868 return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
9869}
9870
9871func (ec *executionContext) fieldContext_Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9872 fc = &graphql.FieldContext{
9873 Object: "Mutation",
9874 Field: field,
9875 IsMethod: true,
9876 IsResolver: true,
9877 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9878 switch field.Name {
9879 case "clientMutationId":
9880 return ec.fieldContext_CloseBugPayload_clientMutationId(ctx, field)
9881 case "bug":
9882 return ec.fieldContext_CloseBugPayload_bug(ctx, field)
9883 case "operation":
9884 return ec.fieldContext_CloseBugPayload_operation(ctx, field)
9885 }
9886 return nil, fmt.Errorf("no field named %q was found under type CloseBugPayload", field.Name)
9887 },
9888 }
9889 defer func() {
9890 if r := recover(); r != nil {
9891 err = ec.Recover(ctx, r)
9892 ec.Error(ctx, err)
9893 }
9894 }()
9895 ctx = graphql.WithFieldContext(ctx, fc)
9896 if fc.Args, err = ec.field_Mutation_closeBug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9897 ec.Error(ctx, err)
9898 return
9899 }
9900 return fc, nil
9901}
9902
9903func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9904 fc, err := ec.fieldContext_Mutation_setTitle(ctx, field)
9905 if err != nil {
9906 return graphql.Null
9907 }
9908 ctx = graphql.WithFieldContext(ctx, fc)
9909 defer func() {
9910 if r := recover(); r != nil {
9911 ec.Error(ctx, ec.Recover(ctx, r))
9912 ret = graphql.Null
9913 }
9914 }()
9915 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9916 ctx = rctx // use context from middleware stack in children
9917 return ec.resolvers.Mutation().SetTitle(rctx, fc.Args["input"].(models.SetTitleInput))
9918 })
9919 if err != nil {
9920 ec.Error(ctx, err)
9921 return graphql.Null
9922 }
9923 if resTmp == nil {
9924 if !graphql.HasFieldError(ctx, fc) {
9925 ec.Errorf(ctx, "must not be null")
9926 }
9927 return graphql.Null
9928 }
9929 res := resTmp.(*models.SetTitlePayload)
9930 fc.Result = res
9931 return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
9932}
9933
9934func (ec *executionContext) fieldContext_Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9935 fc = &graphql.FieldContext{
9936 Object: "Mutation",
9937 Field: field,
9938 IsMethod: true,
9939 IsResolver: true,
9940 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9941 switch field.Name {
9942 case "clientMutationId":
9943 return ec.fieldContext_SetTitlePayload_clientMutationId(ctx, field)
9944 case "bug":
9945 return ec.fieldContext_SetTitlePayload_bug(ctx, field)
9946 case "operation":
9947 return ec.fieldContext_SetTitlePayload_operation(ctx, field)
9948 }
9949 return nil, fmt.Errorf("no field named %q was found under type SetTitlePayload", field.Name)
9950 },
9951 }
9952 defer func() {
9953 if r := recover(); r != nil {
9954 err = ec.Recover(ctx, r)
9955 ec.Error(ctx, err)
9956 }
9957 }()
9958 ctx = graphql.WithFieldContext(ctx, fc)
9959 if fc.Args, err = ec.field_Mutation_setTitle_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9960 ec.Error(ctx, err)
9961 return
9962 }
9963 return fc, nil
9964}
9965
9966func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
9967 fc, err := ec.fieldContext_NewBugPayload_clientMutationId(ctx, field)
9968 if err != nil {
9969 return graphql.Null
9970 }
9971 ctx = graphql.WithFieldContext(ctx, fc)
9972 defer func() {
9973 if r := recover(); r != nil {
9974 ec.Error(ctx, ec.Recover(ctx, r))
9975 ret = graphql.Null
9976 }
9977 }()
9978 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9979 ctx = rctx // use context from middleware stack in children
9980 return obj.ClientMutationID, nil
9981 })
9982 if err != nil {
9983 ec.Error(ctx, err)
9984 return graphql.Null
9985 }
9986 if resTmp == nil {
9987 return graphql.Null
9988 }
9989 res := resTmp.(*string)
9990 fc.Result = res
9991 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9992}
9993
9994func (ec *executionContext) fieldContext_NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9995 fc = &graphql.FieldContext{
9996 Object: "NewBugPayload",
9997 Field: field,
9998 IsMethod: false,
9999 IsResolver: false,
10000 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10001 return nil, errors.New("field of type String does not have child fields")
10002 },
10003 }
10004 return fc, nil
10005}
10006
10007func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
10008 fc, err := ec.fieldContext_NewBugPayload_bug(ctx, field)
10009 if err != nil {
10010 return graphql.Null
10011 }
10012 ctx = graphql.WithFieldContext(ctx, fc)
10013 defer func() {
10014 if r := recover(); r != nil {
10015 ec.Error(ctx, ec.Recover(ctx, r))
10016 ret = graphql.Null
10017 }
10018 }()
10019 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10020 ctx = rctx // use context from middleware stack in children
10021 return obj.Bug, nil
10022 })
10023 if err != nil {
10024 ec.Error(ctx, err)
10025 return graphql.Null
10026 }
10027 if resTmp == nil {
10028 if !graphql.HasFieldError(ctx, fc) {
10029 ec.Errorf(ctx, "must not be null")
10030 }
10031 return graphql.Null
10032 }
10033 res := resTmp.(models.BugWrapper)
10034 fc.Result = res
10035 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
10036}
10037
10038func (ec *executionContext) fieldContext_NewBugPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10039 fc = &graphql.FieldContext{
10040 Object: "NewBugPayload",
10041 Field: field,
10042 IsMethod: false,
10043 IsResolver: false,
10044 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10045 switch field.Name {
10046 case "id":
10047 return ec.fieldContext_Bug_id(ctx, field)
10048 case "humanId":
10049 return ec.fieldContext_Bug_humanId(ctx, field)
10050 case "status":
10051 return ec.fieldContext_Bug_status(ctx, field)
10052 case "title":
10053 return ec.fieldContext_Bug_title(ctx, field)
10054 case "labels":
10055 return ec.fieldContext_Bug_labels(ctx, field)
10056 case "author":
10057 return ec.fieldContext_Bug_author(ctx, field)
10058 case "createdAt":
10059 return ec.fieldContext_Bug_createdAt(ctx, field)
10060 case "lastEdit":
10061 return ec.fieldContext_Bug_lastEdit(ctx, field)
10062 case "actors":
10063 return ec.fieldContext_Bug_actors(ctx, field)
10064 case "participants":
10065 return ec.fieldContext_Bug_participants(ctx, field)
10066 case "comments":
10067 return ec.fieldContext_Bug_comments(ctx, field)
10068 case "timeline":
10069 return ec.fieldContext_Bug_timeline(ctx, field)
10070 case "operations":
10071 return ec.fieldContext_Bug_operations(ctx, field)
10072 }
10073 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
10074 },
10075 }
10076 return fc, nil
10077}
10078
10079func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
10080 fc, err := ec.fieldContext_NewBugPayload_operation(ctx, field)
10081 if err != nil {
10082 return graphql.Null
10083 }
10084 ctx = graphql.WithFieldContext(ctx, fc)
10085 defer func() {
10086 if r := recover(); r != nil {
10087 ec.Error(ctx, ec.Recover(ctx, r))
10088 ret = graphql.Null
10089 }
10090 }()
10091 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10092 ctx = rctx // use context from middleware stack in children
10093 return obj.Operation, nil
10094 })
10095 if err != nil {
10096 ec.Error(ctx, err)
10097 return graphql.Null
10098 }
10099 if resTmp == nil {
10100 if !graphql.HasFieldError(ctx, fc) {
10101 ec.Errorf(ctx, "must not be null")
10102 }
10103 return graphql.Null
10104 }
10105 res := resTmp.(*bug.CreateOperation)
10106 fc.Result = res
10107 return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
10108}
10109
10110func (ec *executionContext) fieldContext_NewBugPayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10111 fc = &graphql.FieldContext{
10112 Object: "NewBugPayload",
10113 Field: field,
10114 IsMethod: false,
10115 IsResolver: false,
10116 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10117 switch field.Name {
10118 case "id":
10119 return ec.fieldContext_CreateOperation_id(ctx, field)
10120 case "author":
10121 return ec.fieldContext_CreateOperation_author(ctx, field)
10122 case "date":
10123 return ec.fieldContext_CreateOperation_date(ctx, field)
10124 case "title":
10125 return ec.fieldContext_CreateOperation_title(ctx, field)
10126 case "message":
10127 return ec.fieldContext_CreateOperation_message(ctx, field)
10128 case "files":
10129 return ec.fieldContext_CreateOperation_files(ctx, field)
10130 }
10131 return nil, fmt.Errorf("no field named %q was found under type CreateOperation", field.Name)
10132 },
10133 }
10134 return fc, nil
10135}
10136
10137func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
10138 fc, err := ec.fieldContext_OpenBugPayload_clientMutationId(ctx, field)
10139 if err != nil {
10140 return graphql.Null
10141 }
10142 ctx = graphql.WithFieldContext(ctx, fc)
10143 defer func() {
10144 if r := recover(); r != nil {
10145 ec.Error(ctx, ec.Recover(ctx, r))
10146 ret = graphql.Null
10147 }
10148 }()
10149 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10150 ctx = rctx // use context from middleware stack in children
10151 return obj.ClientMutationID, nil
10152 })
10153 if err != nil {
10154 ec.Error(ctx, err)
10155 return graphql.Null
10156 }
10157 if resTmp == nil {
10158 return graphql.Null
10159 }
10160 res := resTmp.(*string)
10161 fc.Result = res
10162 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10163}
10164
10165func (ec *executionContext) fieldContext_OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10166 fc = &graphql.FieldContext{
10167 Object: "OpenBugPayload",
10168 Field: field,
10169 IsMethod: false,
10170 IsResolver: false,
10171 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10172 return nil, errors.New("field of type String does not have child fields")
10173 },
10174 }
10175 return fc, nil
10176}
10177
10178func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
10179 fc, err := ec.fieldContext_OpenBugPayload_bug(ctx, field)
10180 if err != nil {
10181 return graphql.Null
10182 }
10183 ctx = graphql.WithFieldContext(ctx, fc)
10184 defer func() {
10185 if r := recover(); r != nil {
10186 ec.Error(ctx, ec.Recover(ctx, r))
10187 ret = graphql.Null
10188 }
10189 }()
10190 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10191 ctx = rctx // use context from middleware stack in children
10192 return obj.Bug, nil
10193 })
10194 if err != nil {
10195 ec.Error(ctx, err)
10196 return graphql.Null
10197 }
10198 if resTmp == nil {
10199 if !graphql.HasFieldError(ctx, fc) {
10200 ec.Errorf(ctx, "must not be null")
10201 }
10202 return graphql.Null
10203 }
10204 res := resTmp.(models.BugWrapper)
10205 fc.Result = res
10206 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
10207}
10208
10209func (ec *executionContext) fieldContext_OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10210 fc = &graphql.FieldContext{
10211 Object: "OpenBugPayload",
10212 Field: field,
10213 IsMethod: false,
10214 IsResolver: false,
10215 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10216 switch field.Name {
10217 case "id":
10218 return ec.fieldContext_Bug_id(ctx, field)
10219 case "humanId":
10220 return ec.fieldContext_Bug_humanId(ctx, field)
10221 case "status":
10222 return ec.fieldContext_Bug_status(ctx, field)
10223 case "title":
10224 return ec.fieldContext_Bug_title(ctx, field)
10225 case "labels":
10226 return ec.fieldContext_Bug_labels(ctx, field)
10227 case "author":
10228 return ec.fieldContext_Bug_author(ctx, field)
10229 case "createdAt":
10230 return ec.fieldContext_Bug_createdAt(ctx, field)
10231 case "lastEdit":
10232 return ec.fieldContext_Bug_lastEdit(ctx, field)
10233 case "actors":
10234 return ec.fieldContext_Bug_actors(ctx, field)
10235 case "participants":
10236 return ec.fieldContext_Bug_participants(ctx, field)
10237 case "comments":
10238 return ec.fieldContext_Bug_comments(ctx, field)
10239 case "timeline":
10240 return ec.fieldContext_Bug_timeline(ctx, field)
10241 case "operations":
10242 return ec.fieldContext_Bug_operations(ctx, field)
10243 }
10244 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
10245 },
10246 }
10247 return fc, nil
10248}
10249
10250func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
10251 fc, err := ec.fieldContext_OpenBugPayload_operation(ctx, field)
10252 if err != nil {
10253 return graphql.Null
10254 }
10255 ctx = graphql.WithFieldContext(ctx, fc)
10256 defer func() {
10257 if r := recover(); r != nil {
10258 ec.Error(ctx, ec.Recover(ctx, r))
10259 ret = graphql.Null
10260 }
10261 }()
10262 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10263 ctx = rctx // use context from middleware stack in children
10264 return obj.Operation, nil
10265 })
10266 if err != nil {
10267 ec.Error(ctx, err)
10268 return graphql.Null
10269 }
10270 if resTmp == nil {
10271 if !graphql.HasFieldError(ctx, fc) {
10272 ec.Errorf(ctx, "must not be null")
10273 }
10274 return graphql.Null
10275 }
10276 res := resTmp.(*bug.SetStatusOperation)
10277 fc.Result = res
10278 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
10279}
10280
10281func (ec *executionContext) fieldContext_OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10282 fc = &graphql.FieldContext{
10283 Object: "OpenBugPayload",
10284 Field: field,
10285 IsMethod: false,
10286 IsResolver: false,
10287 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10288 switch field.Name {
10289 case "id":
10290 return ec.fieldContext_SetStatusOperation_id(ctx, field)
10291 case "author":
10292 return ec.fieldContext_SetStatusOperation_author(ctx, field)
10293 case "date":
10294 return ec.fieldContext_SetStatusOperation_date(ctx, field)
10295 case "status":
10296 return ec.fieldContext_SetStatusOperation_status(ctx, field)
10297 }
10298 return nil, fmt.Errorf("no field named %q was found under type SetStatusOperation", field.Name)
10299 },
10300 }
10301 return fc, nil
10302}
10303
10304func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
10305 fc, err := ec.fieldContext_OperationConnection_edges(ctx, field)
10306 if err != nil {
10307 return graphql.Null
10308 }
10309 ctx = graphql.WithFieldContext(ctx, fc)
10310 defer func() {
10311 if r := recover(); r != nil {
10312 ec.Error(ctx, ec.Recover(ctx, r))
10313 ret = graphql.Null
10314 }
10315 }()
10316 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10317 ctx = rctx // use context from middleware stack in children
10318 return obj.Edges, nil
10319 })
10320 if err != nil {
10321 ec.Error(ctx, err)
10322 return graphql.Null
10323 }
10324 if resTmp == nil {
10325 if !graphql.HasFieldError(ctx, fc) {
10326 ec.Errorf(ctx, "must not be null")
10327 }
10328 return graphql.Null
10329 }
10330 res := resTmp.([]*models.OperationEdge)
10331 fc.Result = res
10332 return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
10333}
10334
10335func (ec *executionContext) fieldContext_OperationConnection_edges(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10336 fc = &graphql.FieldContext{
10337 Object: "OperationConnection",
10338 Field: field,
10339 IsMethod: false,
10340 IsResolver: false,
10341 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10342 switch field.Name {
10343 case "cursor":
10344 return ec.fieldContext_OperationEdge_cursor(ctx, field)
10345 case "node":
10346 return ec.fieldContext_OperationEdge_node(ctx, field)
10347 }
10348 return nil, fmt.Errorf("no field named %q was found under type OperationEdge", field.Name)
10349 },
10350 }
10351 return fc, nil
10352}
10353
10354func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
10355 fc, err := ec.fieldContext_OperationConnection_nodes(ctx, field)
10356 if err != nil {
10357 return graphql.Null
10358 }
10359 ctx = graphql.WithFieldContext(ctx, fc)
10360 defer func() {
10361 if r := recover(); r != nil {
10362 ec.Error(ctx, ec.Recover(ctx, r))
10363 ret = graphql.Null
10364 }
10365 }()
10366 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10367 ctx = rctx // use context from middleware stack in children
10368 return obj.Nodes, nil
10369 })
10370 if err != nil {
10371 ec.Error(ctx, err)
10372 return graphql.Null
10373 }
10374 if resTmp == nil {
10375 if !graphql.HasFieldError(ctx, fc) {
10376 ec.Errorf(ctx, "must not be null")
10377 }
10378 return graphql.Null
10379 }
10380 res := resTmp.([]dag.Operation)
10381 fc.Result = res
10382 return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentityᚋdagᚐOperationᚄ(ctx, field.Selections, res)
10383}
10384
10385func (ec *executionContext) fieldContext_OperationConnection_nodes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10386 fc = &graphql.FieldContext{
10387 Object: "OperationConnection",
10388 Field: field,
10389 IsMethod: false,
10390 IsResolver: false,
10391 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10392 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
10393 },
10394 }
10395 return fc, nil
10396}
10397
10398func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
10399 fc, err := ec.fieldContext_OperationConnection_pageInfo(ctx, field)
10400 if err != nil {
10401 return graphql.Null
10402 }
10403 ctx = graphql.WithFieldContext(ctx, fc)
10404 defer func() {
10405 if r := recover(); r != nil {
10406 ec.Error(ctx, ec.Recover(ctx, r))
10407 ret = graphql.Null
10408 }
10409 }()
10410 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10411 ctx = rctx // use context from middleware stack in children
10412 return obj.PageInfo, nil
10413 })
10414 if err != nil {
10415 ec.Error(ctx, err)
10416 return graphql.Null
10417 }
10418 if resTmp == nil {
10419 if !graphql.HasFieldError(ctx, fc) {
10420 ec.Errorf(ctx, "must not be null")
10421 }
10422 return graphql.Null
10423 }
10424 res := resTmp.(*models.PageInfo)
10425 fc.Result = res
10426 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
10427}
10428
10429func (ec *executionContext) fieldContext_OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10430 fc = &graphql.FieldContext{
10431 Object: "OperationConnection",
10432 Field: field,
10433 IsMethod: false,
10434 IsResolver: false,
10435 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10436 switch field.Name {
10437 case "hasNextPage":
10438 return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
10439 case "hasPreviousPage":
10440 return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
10441 case "startCursor":
10442 return ec.fieldContext_PageInfo_startCursor(ctx, field)
10443 case "endCursor":
10444 return ec.fieldContext_PageInfo_endCursor(ctx, field)
10445 }
10446 return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
10447 },
10448 }
10449 return fc, nil
10450}
10451
10452func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
10453 fc, err := ec.fieldContext_OperationConnection_totalCount(ctx, field)
10454 if err != nil {
10455 return graphql.Null
10456 }
10457 ctx = graphql.WithFieldContext(ctx, fc)
10458 defer func() {
10459 if r := recover(); r != nil {
10460 ec.Error(ctx, ec.Recover(ctx, r))
10461 ret = graphql.Null
10462 }
10463 }()
10464 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10465 ctx = rctx // use context from middleware stack in children
10466 return obj.TotalCount, nil
10467 })
10468 if err != nil {
10469 ec.Error(ctx, err)
10470 return graphql.Null
10471 }
10472 if resTmp == nil {
10473 if !graphql.HasFieldError(ctx, fc) {
10474 ec.Errorf(ctx, "must not be null")
10475 }
10476 return graphql.Null
10477 }
10478 res := resTmp.(int)
10479 fc.Result = res
10480 return ec.marshalNInt2int(ctx, field.Selections, res)
10481}
10482
10483func (ec *executionContext) fieldContext_OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10484 fc = &graphql.FieldContext{
10485 Object: "OperationConnection",
10486 Field: field,
10487 IsMethod: false,
10488 IsResolver: false,
10489 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10490 return nil, errors.New("field of type Int does not have child fields")
10491 },
10492 }
10493 return fc, nil
10494}
10495
10496func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
10497 fc, err := ec.fieldContext_OperationEdge_cursor(ctx, field)
10498 if err != nil {
10499 return graphql.Null
10500 }
10501 ctx = graphql.WithFieldContext(ctx, fc)
10502 defer func() {
10503 if r := recover(); r != nil {
10504 ec.Error(ctx, ec.Recover(ctx, r))
10505 ret = graphql.Null
10506 }
10507 }()
10508 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10509 ctx = rctx // use context from middleware stack in children
10510 return obj.Cursor, nil
10511 })
10512 if err != nil {
10513 ec.Error(ctx, err)
10514 return graphql.Null
10515 }
10516 if resTmp == nil {
10517 if !graphql.HasFieldError(ctx, fc) {
10518 ec.Errorf(ctx, "must not be null")
10519 }
10520 return graphql.Null
10521 }
10522 res := resTmp.(string)
10523 fc.Result = res
10524 return ec.marshalNString2string(ctx, field.Selections, res)
10525}
10526
10527func (ec *executionContext) fieldContext_OperationEdge_cursor(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10528 fc = &graphql.FieldContext{
10529 Object: "OperationEdge",
10530 Field: field,
10531 IsMethod: false,
10532 IsResolver: false,
10533 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10534 return nil, errors.New("field of type String does not have child fields")
10535 },
10536 }
10537 return fc, nil
10538}
10539
10540func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
10541 fc, err := ec.fieldContext_OperationEdge_node(ctx, field)
10542 if err != nil {
10543 return graphql.Null
10544 }
10545 ctx = graphql.WithFieldContext(ctx, fc)
10546 defer func() {
10547 if r := recover(); r != nil {
10548 ec.Error(ctx, ec.Recover(ctx, r))
10549 ret = graphql.Null
10550 }
10551 }()
10552 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10553 ctx = rctx // use context from middleware stack in children
10554 return obj.Node, nil
10555 })
10556 if err != nil {
10557 ec.Error(ctx, err)
10558 return graphql.Null
10559 }
10560 if resTmp == nil {
10561 if !graphql.HasFieldError(ctx, fc) {
10562 ec.Errorf(ctx, "must not be null")
10563 }
10564 return graphql.Null
10565 }
10566 res := resTmp.(dag.Operation)
10567 fc.Result = res
10568 return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋentityᚋdagᚐOperation(ctx, field.Selections, res)
10569}
10570
10571func (ec *executionContext) fieldContext_OperationEdge_node(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10572 fc = &graphql.FieldContext{
10573 Object: "OperationEdge",
10574 Field: field,
10575 IsMethod: false,
10576 IsResolver: false,
10577 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10578 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
10579 },
10580 }
10581 return fc, nil
10582}
10583
10584func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
10585 fc, err := ec.fieldContext_PageInfo_hasNextPage(ctx, field)
10586 if err != nil {
10587 return graphql.Null
10588 }
10589 ctx = graphql.WithFieldContext(ctx, fc)
10590 defer func() {
10591 if r := recover(); r != nil {
10592 ec.Error(ctx, ec.Recover(ctx, r))
10593 ret = graphql.Null
10594 }
10595 }()
10596 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10597 ctx = rctx // use context from middleware stack in children
10598 return obj.HasNextPage, nil
10599 })
10600 if err != nil {
10601 ec.Error(ctx, err)
10602 return graphql.Null
10603 }
10604 if resTmp == nil {
10605 if !graphql.HasFieldError(ctx, fc) {
10606 ec.Errorf(ctx, "must not be null")
10607 }
10608 return graphql.Null
10609 }
10610 res := resTmp.(bool)
10611 fc.Result = res
10612 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
10613}
10614
10615func (ec *executionContext) fieldContext_PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10616 fc = &graphql.FieldContext{
10617 Object: "PageInfo",
10618 Field: field,
10619 IsMethod: false,
10620 IsResolver: false,
10621 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10622 return nil, errors.New("field of type Boolean does not have child fields")
10623 },
10624 }
10625 return fc, nil
10626}
10627
10628func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
10629 fc, err := ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
10630 if err != nil {
10631 return graphql.Null
10632 }
10633 ctx = graphql.WithFieldContext(ctx, fc)
10634 defer func() {
10635 if r := recover(); r != nil {
10636 ec.Error(ctx, ec.Recover(ctx, r))
10637 ret = graphql.Null
10638 }
10639 }()
10640 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10641 ctx = rctx // use context from middleware stack in children
10642 return obj.HasPreviousPage, nil
10643 })
10644 if err != nil {
10645 ec.Error(ctx, err)
10646 return graphql.Null
10647 }
10648 if resTmp == nil {
10649 if !graphql.HasFieldError(ctx, fc) {
10650 ec.Errorf(ctx, "must not be null")
10651 }
10652 return graphql.Null
10653 }
10654 res := resTmp.(bool)
10655 fc.Result = res
10656 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
10657}
10658
10659func (ec *executionContext) fieldContext_PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10660 fc = &graphql.FieldContext{
10661 Object: "PageInfo",
10662 Field: field,
10663 IsMethod: false,
10664 IsResolver: false,
10665 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10666 return nil, errors.New("field of type Boolean does not have child fields")
10667 },
10668 }
10669 return fc, nil
10670}
10671
10672func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
10673 fc, err := ec.fieldContext_PageInfo_startCursor(ctx, field)
10674 if err != nil {
10675 return graphql.Null
10676 }
10677 ctx = graphql.WithFieldContext(ctx, fc)
10678 defer func() {
10679 if r := recover(); r != nil {
10680 ec.Error(ctx, ec.Recover(ctx, r))
10681 ret = graphql.Null
10682 }
10683 }()
10684 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10685 ctx = rctx // use context from middleware stack in children
10686 return obj.StartCursor, nil
10687 })
10688 if err != nil {
10689 ec.Error(ctx, err)
10690 return graphql.Null
10691 }
10692 if resTmp == nil {
10693 if !graphql.HasFieldError(ctx, fc) {
10694 ec.Errorf(ctx, "must not be null")
10695 }
10696 return graphql.Null
10697 }
10698 res := resTmp.(string)
10699 fc.Result = res
10700 return ec.marshalNString2string(ctx, field.Selections, res)
10701}
10702
10703func (ec *executionContext) fieldContext_PageInfo_startCursor(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10704 fc = &graphql.FieldContext{
10705 Object: "PageInfo",
10706 Field: field,
10707 IsMethod: false,
10708 IsResolver: false,
10709 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10710 return nil, errors.New("field of type String does not have child fields")
10711 },
10712 }
10713 return fc, nil
10714}
10715
10716func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
10717 fc, err := ec.fieldContext_PageInfo_endCursor(ctx, field)
10718 if err != nil {
10719 return graphql.Null
10720 }
10721 ctx = graphql.WithFieldContext(ctx, fc)
10722 defer func() {
10723 if r := recover(); r != nil {
10724 ec.Error(ctx, ec.Recover(ctx, r))
10725 ret = graphql.Null
10726 }
10727 }()
10728 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10729 ctx = rctx // use context from middleware stack in children
10730 return obj.EndCursor, nil
10731 })
10732 if err != nil {
10733 ec.Error(ctx, err)
10734 return graphql.Null
10735 }
10736 if resTmp == nil {
10737 if !graphql.HasFieldError(ctx, fc) {
10738 ec.Errorf(ctx, "must not be null")
10739 }
10740 return graphql.Null
10741 }
10742 res := resTmp.(string)
10743 fc.Result = res
10744 return ec.marshalNString2string(ctx, field.Selections, res)
10745}
10746
10747func (ec *executionContext) fieldContext_PageInfo_endCursor(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10748 fc = &graphql.FieldContext{
10749 Object: "PageInfo",
10750 Field: field,
10751 IsMethod: false,
10752 IsResolver: false,
10753 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10754 return nil, errors.New("field of type String does not have child fields")
10755 },
10756 }
10757 return fc, nil
10758}
10759
10760func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10761 fc, err := ec.fieldContext_Query_repository(ctx, field)
10762 if err != nil {
10763 return graphql.Null
10764 }
10765 ctx = graphql.WithFieldContext(ctx, fc)
10766 defer func() {
10767 if r := recover(); r != nil {
10768 ec.Error(ctx, ec.Recover(ctx, r))
10769 ret = graphql.Null
10770 }
10771 }()
10772 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10773 ctx = rctx // use context from middleware stack in children
10774 return ec.resolvers.Query().Repository(rctx, fc.Args["ref"].(*string))
10775 })
10776 if err != nil {
10777 ec.Error(ctx, err)
10778 return graphql.Null
10779 }
10780 if resTmp == nil {
10781 return graphql.Null
10782 }
10783 res := resTmp.(*models.Repository)
10784 fc.Result = res
10785 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
10786}
10787
10788func (ec *executionContext) fieldContext_Query_repository(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10789 fc = &graphql.FieldContext{
10790 Object: "Query",
10791 Field: field,
10792 IsMethod: true,
10793 IsResolver: true,
10794 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10795 switch field.Name {
10796 case "name":
10797 return ec.fieldContext_Repository_name(ctx, field)
10798 case "allBugs":
10799 return ec.fieldContext_Repository_allBugs(ctx, field)
10800 case "bug":
10801 return ec.fieldContext_Repository_bug(ctx, field)
10802 case "allIdentities":
10803 return ec.fieldContext_Repository_allIdentities(ctx, field)
10804 case "identity":
10805 return ec.fieldContext_Repository_identity(ctx, field)
10806 case "userIdentity":
10807 return ec.fieldContext_Repository_userIdentity(ctx, field)
10808 case "validLabels":
10809 return ec.fieldContext_Repository_validLabels(ctx, field)
10810 }
10811 return nil, fmt.Errorf("no field named %q was found under type Repository", field.Name)
10812 },
10813 }
10814 defer func() {
10815 if r := recover(); r != nil {
10816 err = ec.Recover(ctx, r)
10817 ec.Error(ctx, err)
10818 }
10819 }()
10820 ctx = graphql.WithFieldContext(ctx, fc)
10821 if fc.Args, err = ec.field_Query_repository_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
10822 ec.Error(ctx, err)
10823 return
10824 }
10825 return fc, nil
10826}
10827
10828func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10829 fc, err := ec.fieldContext_Query___type(ctx, field)
10830 if err != nil {
10831 return graphql.Null
10832 }
10833 ctx = graphql.WithFieldContext(ctx, fc)
10834 defer func() {
10835 if r := recover(); r != nil {
10836 ec.Error(ctx, ec.Recover(ctx, r))
10837 ret = graphql.Null
10838 }
10839 }()
10840 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10841 ctx = rctx // use context from middleware stack in children
10842 return ec.introspectType(fc.Args["name"].(string))
10843 })
10844 if err != nil {
10845 ec.Error(ctx, err)
10846 return graphql.Null
10847 }
10848 if resTmp == nil {
10849 return graphql.Null
10850 }
10851 res := resTmp.(*introspection.Type)
10852 fc.Result = res
10853 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10854}
10855
10856func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10857 fc = &graphql.FieldContext{
10858 Object: "Query",
10859 Field: field,
10860 IsMethod: true,
10861 IsResolver: false,
10862 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10863 switch field.Name {
10864 case "kind":
10865 return ec.fieldContext___Type_kind(ctx, field)
10866 case "name":
10867 return ec.fieldContext___Type_name(ctx, field)
10868 case "description":
10869 return ec.fieldContext___Type_description(ctx, field)
10870 case "fields":
10871 return ec.fieldContext___Type_fields(ctx, field)
10872 case "interfaces":
10873 return ec.fieldContext___Type_interfaces(ctx, field)
10874 case "possibleTypes":
10875 return ec.fieldContext___Type_possibleTypes(ctx, field)
10876 case "enumValues":
10877 return ec.fieldContext___Type_enumValues(ctx, field)
10878 case "inputFields":
10879 return ec.fieldContext___Type_inputFields(ctx, field)
10880 case "ofType":
10881 return ec.fieldContext___Type_ofType(ctx, field)
10882 case "specifiedByURL":
10883 return ec.fieldContext___Type_specifiedByURL(ctx, field)
10884 }
10885 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
10886 },
10887 }
10888 defer func() {
10889 if r := recover(); r != nil {
10890 err = ec.Recover(ctx, r)
10891 ec.Error(ctx, err)
10892 }
10893 }()
10894 ctx = graphql.WithFieldContext(ctx, fc)
10895 if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
10896 ec.Error(ctx, err)
10897 return
10898 }
10899 return fc, nil
10900}
10901
10902func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10903 fc, err := ec.fieldContext_Query___schema(ctx, field)
10904 if err != nil {
10905 return graphql.Null
10906 }
10907 ctx = graphql.WithFieldContext(ctx, fc)
10908 defer func() {
10909 if r := recover(); r != nil {
10910 ec.Error(ctx, ec.Recover(ctx, r))
10911 ret = graphql.Null
10912 }
10913 }()
10914 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10915 ctx = rctx // use context from middleware stack in children
10916 return ec.introspectSchema()
10917 })
10918 if err != nil {
10919 ec.Error(ctx, err)
10920 return graphql.Null
10921 }
10922 if resTmp == nil {
10923 return graphql.Null
10924 }
10925 res := resTmp.(*introspection.Schema)
10926 fc.Result = res
10927 return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
10928}
10929
10930func (ec *executionContext) fieldContext_Query___schema(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10931 fc = &graphql.FieldContext{
10932 Object: "Query",
10933 Field: field,
10934 IsMethod: true,
10935 IsResolver: false,
10936 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10937 switch field.Name {
10938 case "description":
10939 return ec.fieldContext___Schema_description(ctx, field)
10940 case "types":
10941 return ec.fieldContext___Schema_types(ctx, field)
10942 case "queryType":
10943 return ec.fieldContext___Schema_queryType(ctx, field)
10944 case "mutationType":
10945 return ec.fieldContext___Schema_mutationType(ctx, field)
10946 case "subscriptionType":
10947 return ec.fieldContext___Schema_subscriptionType(ctx, field)
10948 case "directives":
10949 return ec.fieldContext___Schema_directives(ctx, field)
10950 }
10951 return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name)
10952 },
10953 }
10954 return fc, nil
10955}
10956
10957func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
10958 fc, err := ec.fieldContext_Repository_name(ctx, field)
10959 if err != nil {
10960 return graphql.Null
10961 }
10962 ctx = graphql.WithFieldContext(ctx, fc)
10963 defer func() {
10964 if r := recover(); r != nil {
10965 ec.Error(ctx, ec.Recover(ctx, r))
10966 ret = graphql.Null
10967 }
10968 }()
10969 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10970 ctx = rctx // use context from middleware stack in children
10971 return ec.resolvers.Repository().Name(rctx, obj)
10972 })
10973 if err != nil {
10974 ec.Error(ctx, err)
10975 return graphql.Null
10976 }
10977 if resTmp == nil {
10978 return graphql.Null
10979 }
10980 res := resTmp.(*string)
10981 fc.Result = res
10982 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10983}
10984
10985func (ec *executionContext) fieldContext_Repository_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10986 fc = &graphql.FieldContext{
10987 Object: "Repository",
10988 Field: field,
10989 IsMethod: true,
10990 IsResolver: true,
10991 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10992 return nil, errors.New("field of type String does not have child fields")
10993 },
10994 }
10995 return fc, nil
10996}
10997
10998func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
10999 fc, err := ec.fieldContext_Repository_allBugs(ctx, field)
11000 if err != nil {
11001 return graphql.Null
11002 }
11003 ctx = graphql.WithFieldContext(ctx, fc)
11004 defer func() {
11005 if r := recover(); r != nil {
11006 ec.Error(ctx, ec.Recover(ctx, r))
11007 ret = graphql.Null
11008 }
11009 }()
11010 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11011 ctx = rctx // use context from middleware stack in children
11012 return ec.resolvers.Repository().AllBugs(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int), fc.Args["query"].(*string))
11013 })
11014 if err != nil {
11015 ec.Error(ctx, err)
11016 return graphql.Null
11017 }
11018 if resTmp == nil {
11019 if !graphql.HasFieldError(ctx, fc) {
11020 ec.Errorf(ctx, "must not be null")
11021 }
11022 return graphql.Null
11023 }
11024 res := resTmp.(*models.BugConnection)
11025 fc.Result = res
11026 return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
11027}
11028
11029func (ec *executionContext) fieldContext_Repository_allBugs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11030 fc = &graphql.FieldContext{
11031 Object: "Repository",
11032 Field: field,
11033 IsMethod: true,
11034 IsResolver: true,
11035 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11036 switch field.Name {
11037 case "edges":
11038 return ec.fieldContext_BugConnection_edges(ctx, field)
11039 case "nodes":
11040 return ec.fieldContext_BugConnection_nodes(ctx, field)
11041 case "pageInfo":
11042 return ec.fieldContext_BugConnection_pageInfo(ctx, field)
11043 case "totalCount":
11044 return ec.fieldContext_BugConnection_totalCount(ctx, field)
11045 }
11046 return nil, fmt.Errorf("no field named %q was found under type BugConnection", field.Name)
11047 },
11048 }
11049 defer func() {
11050 if r := recover(); r != nil {
11051 err = ec.Recover(ctx, r)
11052 ec.Error(ctx, err)
11053 }
11054 }()
11055 ctx = graphql.WithFieldContext(ctx, fc)
11056 if fc.Args, err = ec.field_Repository_allBugs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
11057 ec.Error(ctx, err)
11058 return
11059 }
11060 return fc, nil
11061}
11062
11063func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
11064 fc, err := ec.fieldContext_Repository_bug(ctx, field)
11065 if err != nil {
11066 return graphql.Null
11067 }
11068 ctx = graphql.WithFieldContext(ctx, fc)
11069 defer func() {
11070 if r := recover(); r != nil {
11071 ec.Error(ctx, ec.Recover(ctx, r))
11072 ret = graphql.Null
11073 }
11074 }()
11075 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11076 ctx = rctx // use context from middleware stack in children
11077 return ec.resolvers.Repository().Bug(rctx, obj, fc.Args["prefix"].(string))
11078 })
11079 if err != nil {
11080 ec.Error(ctx, err)
11081 return graphql.Null
11082 }
11083 if resTmp == nil {
11084 return graphql.Null
11085 }
11086 res := resTmp.(models.BugWrapper)
11087 fc.Result = res
11088 return ec.marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
11089}
11090
11091func (ec *executionContext) fieldContext_Repository_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11092 fc = &graphql.FieldContext{
11093 Object: "Repository",
11094 Field: field,
11095 IsMethod: true,
11096 IsResolver: true,
11097 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11098 switch field.Name {
11099 case "id":
11100 return ec.fieldContext_Bug_id(ctx, field)
11101 case "humanId":
11102 return ec.fieldContext_Bug_humanId(ctx, field)
11103 case "status":
11104 return ec.fieldContext_Bug_status(ctx, field)
11105 case "title":
11106 return ec.fieldContext_Bug_title(ctx, field)
11107 case "labels":
11108 return ec.fieldContext_Bug_labels(ctx, field)
11109 case "author":
11110 return ec.fieldContext_Bug_author(ctx, field)
11111 case "createdAt":
11112 return ec.fieldContext_Bug_createdAt(ctx, field)
11113 case "lastEdit":
11114 return ec.fieldContext_Bug_lastEdit(ctx, field)
11115 case "actors":
11116 return ec.fieldContext_Bug_actors(ctx, field)
11117 case "participants":
11118 return ec.fieldContext_Bug_participants(ctx, field)
11119 case "comments":
11120 return ec.fieldContext_Bug_comments(ctx, field)
11121 case "timeline":
11122 return ec.fieldContext_Bug_timeline(ctx, field)
11123 case "operations":
11124 return ec.fieldContext_Bug_operations(ctx, field)
11125 }
11126 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
11127 },
11128 }
11129 defer func() {
11130 if r := recover(); r != nil {
11131 err = ec.Recover(ctx, r)
11132 ec.Error(ctx, err)
11133 }
11134 }()
11135 ctx = graphql.WithFieldContext(ctx, fc)
11136 if fc.Args, err = ec.field_Repository_bug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
11137 ec.Error(ctx, err)
11138 return
11139 }
11140 return fc, nil
11141}
11142
11143func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
11144 fc, err := ec.fieldContext_Repository_allIdentities(ctx, field)
11145 if err != nil {
11146 return graphql.Null
11147 }
11148 ctx = graphql.WithFieldContext(ctx, fc)
11149 defer func() {
11150 if r := recover(); r != nil {
11151 ec.Error(ctx, ec.Recover(ctx, r))
11152 ret = graphql.Null
11153 }
11154 }()
11155 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11156 ctx = rctx // use context from middleware stack in children
11157 return ec.resolvers.Repository().AllIdentities(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
11158 })
11159 if err != nil {
11160 ec.Error(ctx, err)
11161 return graphql.Null
11162 }
11163 if resTmp == nil {
11164 if !graphql.HasFieldError(ctx, fc) {
11165 ec.Errorf(ctx, "must not be null")
11166 }
11167 return graphql.Null
11168 }
11169 res := resTmp.(*models.IdentityConnection)
11170 fc.Result = res
11171 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
11172}
11173
11174func (ec *executionContext) fieldContext_Repository_allIdentities(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11175 fc = &graphql.FieldContext{
11176 Object: "Repository",
11177 Field: field,
11178 IsMethod: true,
11179 IsResolver: true,
11180 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11181 switch field.Name {
11182 case "edges":
11183 return ec.fieldContext_IdentityConnection_edges(ctx, field)
11184 case "nodes":
11185 return ec.fieldContext_IdentityConnection_nodes(ctx, field)
11186 case "pageInfo":
11187 return ec.fieldContext_IdentityConnection_pageInfo(ctx, field)
11188 case "totalCount":
11189 return ec.fieldContext_IdentityConnection_totalCount(ctx, field)
11190 }
11191 return nil, fmt.Errorf("no field named %q was found under type IdentityConnection", field.Name)
11192 },
11193 }
11194 defer func() {
11195 if r := recover(); r != nil {
11196 err = ec.Recover(ctx, r)
11197 ec.Error(ctx, err)
11198 }
11199 }()
11200 ctx = graphql.WithFieldContext(ctx, fc)
11201 if fc.Args, err = ec.field_Repository_allIdentities_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
11202 ec.Error(ctx, err)
11203 return
11204 }
11205 return fc, nil
11206}
11207
11208func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
11209 fc, err := ec.fieldContext_Repository_identity(ctx, field)
11210 if err != nil {
11211 return graphql.Null
11212 }
11213 ctx = graphql.WithFieldContext(ctx, fc)
11214 defer func() {
11215 if r := recover(); r != nil {
11216 ec.Error(ctx, ec.Recover(ctx, r))
11217 ret = graphql.Null
11218 }
11219 }()
11220 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11221 ctx = rctx // use context from middleware stack in children
11222 return ec.resolvers.Repository().Identity(rctx, obj, fc.Args["prefix"].(string))
11223 })
11224 if err != nil {
11225 ec.Error(ctx, err)
11226 return graphql.Null
11227 }
11228 if resTmp == nil {
11229 return graphql.Null
11230 }
11231 res := resTmp.(models.IdentityWrapper)
11232 fc.Result = res
11233 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
11234}
11235
11236func (ec *executionContext) fieldContext_Repository_identity(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11237 fc = &graphql.FieldContext{
11238 Object: "Repository",
11239 Field: field,
11240 IsMethod: true,
11241 IsResolver: true,
11242 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11243 switch field.Name {
11244 case "id":
11245 return ec.fieldContext_Identity_id(ctx, field)
11246 case "humanId":
11247 return ec.fieldContext_Identity_humanId(ctx, field)
11248 case "name":
11249 return ec.fieldContext_Identity_name(ctx, field)
11250 case "email":
11251 return ec.fieldContext_Identity_email(ctx, field)
11252 case "login":
11253 return ec.fieldContext_Identity_login(ctx, field)
11254 case "displayName":
11255 return ec.fieldContext_Identity_displayName(ctx, field)
11256 case "avatarUrl":
11257 return ec.fieldContext_Identity_avatarUrl(ctx, field)
11258 case "isProtected":
11259 return ec.fieldContext_Identity_isProtected(ctx, field)
11260 }
11261 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
11262 },
11263 }
11264 defer func() {
11265 if r := recover(); r != nil {
11266 err = ec.Recover(ctx, r)
11267 ec.Error(ctx, err)
11268 }
11269 }()
11270 ctx = graphql.WithFieldContext(ctx, fc)
11271 if fc.Args, err = ec.field_Repository_identity_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
11272 ec.Error(ctx, err)
11273 return
11274 }
11275 return fc, nil
11276}
11277
11278func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
11279 fc, err := ec.fieldContext_Repository_userIdentity(ctx, field)
11280 if err != nil {
11281 return graphql.Null
11282 }
11283 ctx = graphql.WithFieldContext(ctx, fc)
11284 defer func() {
11285 if r := recover(); r != nil {
11286 ec.Error(ctx, ec.Recover(ctx, r))
11287 ret = graphql.Null
11288 }
11289 }()
11290 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11291 ctx = rctx // use context from middleware stack in children
11292 return ec.resolvers.Repository().UserIdentity(rctx, obj)
11293 })
11294 if err != nil {
11295 ec.Error(ctx, err)
11296 return graphql.Null
11297 }
11298 if resTmp == nil {
11299 return graphql.Null
11300 }
11301 res := resTmp.(models.IdentityWrapper)
11302 fc.Result = res
11303 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
11304}
11305
11306func (ec *executionContext) fieldContext_Repository_userIdentity(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11307 fc = &graphql.FieldContext{
11308 Object: "Repository",
11309 Field: field,
11310 IsMethod: true,
11311 IsResolver: true,
11312 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11313 switch field.Name {
11314 case "id":
11315 return ec.fieldContext_Identity_id(ctx, field)
11316 case "humanId":
11317 return ec.fieldContext_Identity_humanId(ctx, field)
11318 case "name":
11319 return ec.fieldContext_Identity_name(ctx, field)
11320 case "email":
11321 return ec.fieldContext_Identity_email(ctx, field)
11322 case "login":
11323 return ec.fieldContext_Identity_login(ctx, field)
11324 case "displayName":
11325 return ec.fieldContext_Identity_displayName(ctx, field)
11326 case "avatarUrl":
11327 return ec.fieldContext_Identity_avatarUrl(ctx, field)
11328 case "isProtected":
11329 return ec.fieldContext_Identity_isProtected(ctx, field)
11330 }
11331 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
11332 },
11333 }
11334 return fc, nil
11335}
11336
11337func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
11338 fc, err := ec.fieldContext_Repository_validLabels(ctx, field)
11339 if err != nil {
11340 return graphql.Null
11341 }
11342 ctx = graphql.WithFieldContext(ctx, fc)
11343 defer func() {
11344 if r := recover(); r != nil {
11345 ec.Error(ctx, ec.Recover(ctx, r))
11346 ret = graphql.Null
11347 }
11348 }()
11349 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11350 ctx = rctx // use context from middleware stack in children
11351 return ec.resolvers.Repository().ValidLabels(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
11352 })
11353 if err != nil {
11354 ec.Error(ctx, err)
11355 return graphql.Null
11356 }
11357 if resTmp == nil {
11358 if !graphql.HasFieldError(ctx, fc) {
11359 ec.Errorf(ctx, "must not be null")
11360 }
11361 return graphql.Null
11362 }
11363 res := resTmp.(*models.LabelConnection)
11364 fc.Result = res
11365 return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
11366}
11367
11368func (ec *executionContext) fieldContext_Repository_validLabels(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11369 fc = &graphql.FieldContext{
11370 Object: "Repository",
11371 Field: field,
11372 IsMethod: true,
11373 IsResolver: true,
11374 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11375 switch field.Name {
11376 case "edges":
11377 return ec.fieldContext_LabelConnection_edges(ctx, field)
11378 case "nodes":
11379 return ec.fieldContext_LabelConnection_nodes(ctx, field)
11380 case "pageInfo":
11381 return ec.fieldContext_LabelConnection_pageInfo(ctx, field)
11382 case "totalCount":
11383 return ec.fieldContext_LabelConnection_totalCount(ctx, field)
11384 }
11385 return nil, fmt.Errorf("no field named %q was found under type LabelConnection", field.Name)
11386 },
11387 }
11388 defer func() {
11389 if r := recover(); r != nil {
11390 err = ec.Recover(ctx, r)
11391 ec.Error(ctx, err)
11392 }
11393 }()
11394 ctx = graphql.WithFieldContext(ctx, fc)
11395 if fc.Args, err = ec.field_Repository_validLabels_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
11396 ec.Error(ctx, err)
11397 return
11398 }
11399 return fc, nil
11400}
11401
11402func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
11403 fc, err := ec.fieldContext_SetStatusOperation_id(ctx, field)
11404 if err != nil {
11405 return graphql.Null
11406 }
11407 ctx = graphql.WithFieldContext(ctx, fc)
11408 defer func() {
11409 if r := recover(); r != nil {
11410 ec.Error(ctx, ec.Recover(ctx, r))
11411 ret = graphql.Null
11412 }
11413 }()
11414 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11415 ctx = rctx // use context from middleware stack in children
11416 return ec.resolvers.SetStatusOperation().ID(rctx, obj)
11417 })
11418 if err != nil {
11419 ec.Error(ctx, err)
11420 return graphql.Null
11421 }
11422 if resTmp == nil {
11423 if !graphql.HasFieldError(ctx, fc) {
11424 ec.Errorf(ctx, "must not be null")
11425 }
11426 return graphql.Null
11427 }
11428 res := resTmp.(string)
11429 fc.Result = res
11430 return ec.marshalNString2string(ctx, field.Selections, res)
11431}
11432
11433func (ec *executionContext) fieldContext_SetStatusOperation_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11434 fc = &graphql.FieldContext{
11435 Object: "SetStatusOperation",
11436 Field: field,
11437 IsMethod: true,
11438 IsResolver: true,
11439 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11440 return nil, errors.New("field of type String does not have child fields")
11441 },
11442 }
11443 return fc, nil
11444}
11445
11446func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
11447 fc, err := ec.fieldContext_SetStatusOperation_author(ctx, field)
11448 if err != nil {
11449 return graphql.Null
11450 }
11451 ctx = graphql.WithFieldContext(ctx, fc)
11452 defer func() {
11453 if r := recover(); r != nil {
11454 ec.Error(ctx, ec.Recover(ctx, r))
11455 ret = graphql.Null
11456 }
11457 }()
11458 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11459 ctx = rctx // use context from middleware stack in children
11460 return ec.resolvers.SetStatusOperation().Author(rctx, obj)
11461 })
11462 if err != nil {
11463 ec.Error(ctx, err)
11464 return graphql.Null
11465 }
11466 if resTmp == nil {
11467 if !graphql.HasFieldError(ctx, fc) {
11468 ec.Errorf(ctx, "must not be null")
11469 }
11470 return graphql.Null
11471 }
11472 res := resTmp.(models.IdentityWrapper)
11473 fc.Result = res
11474 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
11475}
11476
11477func (ec *executionContext) fieldContext_SetStatusOperation_author(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11478 fc = &graphql.FieldContext{
11479 Object: "SetStatusOperation",
11480 Field: field,
11481 IsMethod: true,
11482 IsResolver: true,
11483 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11484 switch field.Name {
11485 case "id":
11486 return ec.fieldContext_Identity_id(ctx, field)
11487 case "humanId":
11488 return ec.fieldContext_Identity_humanId(ctx, field)
11489 case "name":
11490 return ec.fieldContext_Identity_name(ctx, field)
11491 case "email":
11492 return ec.fieldContext_Identity_email(ctx, field)
11493 case "login":
11494 return ec.fieldContext_Identity_login(ctx, field)
11495 case "displayName":
11496 return ec.fieldContext_Identity_displayName(ctx, field)
11497 case "avatarUrl":
11498 return ec.fieldContext_Identity_avatarUrl(ctx, field)
11499 case "isProtected":
11500 return ec.fieldContext_Identity_isProtected(ctx, field)
11501 }
11502 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
11503 },
11504 }
11505 return fc, nil
11506}
11507
11508func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
11509 fc, err := ec.fieldContext_SetStatusOperation_date(ctx, field)
11510 if err != nil {
11511 return graphql.Null
11512 }
11513 ctx = graphql.WithFieldContext(ctx, fc)
11514 defer func() {
11515 if r := recover(); r != nil {
11516 ec.Error(ctx, ec.Recover(ctx, r))
11517 ret = graphql.Null
11518 }
11519 }()
11520 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11521 ctx = rctx // use context from middleware stack in children
11522 return ec.resolvers.SetStatusOperation().Date(rctx, obj)
11523 })
11524 if err != nil {
11525 ec.Error(ctx, err)
11526 return graphql.Null
11527 }
11528 if resTmp == nil {
11529 if !graphql.HasFieldError(ctx, fc) {
11530 ec.Errorf(ctx, "must not be null")
11531 }
11532 return graphql.Null
11533 }
11534 res := resTmp.(*time.Time)
11535 fc.Result = res
11536 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
11537}
11538
11539func (ec *executionContext) fieldContext_SetStatusOperation_date(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11540 fc = &graphql.FieldContext{
11541 Object: "SetStatusOperation",
11542 Field: field,
11543 IsMethod: true,
11544 IsResolver: true,
11545 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11546 return nil, errors.New("field of type Time does not have child fields")
11547 },
11548 }
11549 return fc, nil
11550}
11551
11552func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
11553 fc, err := ec.fieldContext_SetStatusOperation_status(ctx, field)
11554 if err != nil {
11555 return graphql.Null
11556 }
11557 ctx = graphql.WithFieldContext(ctx, fc)
11558 defer func() {
11559 if r := recover(); r != nil {
11560 ec.Error(ctx, ec.Recover(ctx, r))
11561 ret = graphql.Null
11562 }
11563 }()
11564 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11565 ctx = rctx // use context from middleware stack in children
11566 return ec.resolvers.SetStatusOperation().Status(rctx, obj)
11567 })
11568 if err != nil {
11569 ec.Error(ctx, err)
11570 return graphql.Null
11571 }
11572 if resTmp == nil {
11573 if !graphql.HasFieldError(ctx, fc) {
11574 ec.Errorf(ctx, "must not be null")
11575 }
11576 return graphql.Null
11577 }
11578 res := resTmp.(models.Status)
11579 fc.Result = res
11580 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
11581}
11582
11583func (ec *executionContext) fieldContext_SetStatusOperation_status(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11584 fc = &graphql.FieldContext{
11585 Object: "SetStatusOperation",
11586 Field: field,
11587 IsMethod: true,
11588 IsResolver: true,
11589 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11590 return nil, errors.New("field of type Status does not have child fields")
11591 },
11592 }
11593 return fc, nil
11594}
11595
11596func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
11597 fc, err := ec.fieldContext_SetStatusTimelineItem_id(ctx, field)
11598 if err != nil {
11599 return graphql.Null
11600 }
11601 ctx = graphql.WithFieldContext(ctx, fc)
11602 defer func() {
11603 if r := recover(); r != nil {
11604 ec.Error(ctx, ec.Recover(ctx, r))
11605 ret = graphql.Null
11606 }
11607 }()
11608 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11609 ctx = rctx // use context from middleware stack in children
11610 return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
11611 })
11612 if err != nil {
11613 ec.Error(ctx, err)
11614 return graphql.Null
11615 }
11616 if resTmp == nil {
11617 if !graphql.HasFieldError(ctx, fc) {
11618 ec.Errorf(ctx, "must not be null")
11619 }
11620 return graphql.Null
11621 }
11622 res := resTmp.(string)
11623 fc.Result = res
11624 return ec.marshalNString2string(ctx, field.Selections, res)
11625}
11626
11627func (ec *executionContext) fieldContext_SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11628 fc = &graphql.FieldContext{
11629 Object: "SetStatusTimelineItem",
11630 Field: field,
11631 IsMethod: true,
11632 IsResolver: true,
11633 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11634 return nil, errors.New("field of type String does not have child fields")
11635 },
11636 }
11637 return fc, nil
11638}
11639
11640func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
11641 fc, err := ec.fieldContext_SetStatusTimelineItem_author(ctx, field)
11642 if err != nil {
11643 return graphql.Null
11644 }
11645 ctx = graphql.WithFieldContext(ctx, fc)
11646 defer func() {
11647 if r := recover(); r != nil {
11648 ec.Error(ctx, ec.Recover(ctx, r))
11649 ret = graphql.Null
11650 }
11651 }()
11652 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11653 ctx = rctx // use context from middleware stack in children
11654 return ec.resolvers.SetStatusTimelineItem().Author(rctx, obj)
11655 })
11656 if err != nil {
11657 ec.Error(ctx, err)
11658 return graphql.Null
11659 }
11660 if resTmp == nil {
11661 if !graphql.HasFieldError(ctx, fc) {
11662 ec.Errorf(ctx, "must not be null")
11663 }
11664 return graphql.Null
11665 }
11666 res := resTmp.(models.IdentityWrapper)
11667 fc.Result = res
11668 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
11669}
11670
11671func (ec *executionContext) fieldContext_SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11672 fc = &graphql.FieldContext{
11673 Object: "SetStatusTimelineItem",
11674 Field: field,
11675 IsMethod: true,
11676 IsResolver: true,
11677 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11678 switch field.Name {
11679 case "id":
11680 return ec.fieldContext_Identity_id(ctx, field)
11681 case "humanId":
11682 return ec.fieldContext_Identity_humanId(ctx, field)
11683 case "name":
11684 return ec.fieldContext_Identity_name(ctx, field)
11685 case "email":
11686 return ec.fieldContext_Identity_email(ctx, field)
11687 case "login":
11688 return ec.fieldContext_Identity_login(ctx, field)
11689 case "displayName":
11690 return ec.fieldContext_Identity_displayName(ctx, field)
11691 case "avatarUrl":
11692 return ec.fieldContext_Identity_avatarUrl(ctx, field)
11693 case "isProtected":
11694 return ec.fieldContext_Identity_isProtected(ctx, field)
11695 }
11696 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
11697 },
11698 }
11699 return fc, nil
11700}
11701
11702func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
11703 fc, err := ec.fieldContext_SetStatusTimelineItem_date(ctx, field)
11704 if err != nil {
11705 return graphql.Null
11706 }
11707 ctx = graphql.WithFieldContext(ctx, fc)
11708 defer func() {
11709 if r := recover(); r != nil {
11710 ec.Error(ctx, ec.Recover(ctx, r))
11711 ret = graphql.Null
11712 }
11713 }()
11714 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11715 ctx = rctx // use context from middleware stack in children
11716 return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
11717 })
11718 if err != nil {
11719 ec.Error(ctx, err)
11720 return graphql.Null
11721 }
11722 if resTmp == nil {
11723 if !graphql.HasFieldError(ctx, fc) {
11724 ec.Errorf(ctx, "must not be null")
11725 }
11726 return graphql.Null
11727 }
11728 res := resTmp.(*time.Time)
11729 fc.Result = res
11730 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
11731}
11732
11733func (ec *executionContext) fieldContext_SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11734 fc = &graphql.FieldContext{
11735 Object: "SetStatusTimelineItem",
11736 Field: field,
11737 IsMethod: true,
11738 IsResolver: true,
11739 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11740 return nil, errors.New("field of type Time does not have child fields")
11741 },
11742 }
11743 return fc, nil
11744}
11745
11746func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
11747 fc, err := ec.fieldContext_SetStatusTimelineItem_status(ctx, field)
11748 if err != nil {
11749 return graphql.Null
11750 }
11751 ctx = graphql.WithFieldContext(ctx, fc)
11752 defer func() {
11753 if r := recover(); r != nil {
11754 ec.Error(ctx, ec.Recover(ctx, r))
11755 ret = graphql.Null
11756 }
11757 }()
11758 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11759 ctx = rctx // use context from middleware stack in children
11760 return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
11761 })
11762 if err != nil {
11763 ec.Error(ctx, err)
11764 return graphql.Null
11765 }
11766 if resTmp == nil {
11767 if !graphql.HasFieldError(ctx, fc) {
11768 ec.Errorf(ctx, "must not be null")
11769 }
11770 return graphql.Null
11771 }
11772 res := resTmp.(models.Status)
11773 fc.Result = res
11774 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
11775}
11776
11777func (ec *executionContext) fieldContext_SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11778 fc = &graphql.FieldContext{
11779 Object: "SetStatusTimelineItem",
11780 Field: field,
11781 IsMethod: true,
11782 IsResolver: true,
11783 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11784 return nil, errors.New("field of type Status does not have child fields")
11785 },
11786 }
11787 return fc, nil
11788}
11789
11790func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
11791 fc, err := ec.fieldContext_SetTitleOperation_id(ctx, field)
11792 if err != nil {
11793 return graphql.Null
11794 }
11795 ctx = graphql.WithFieldContext(ctx, fc)
11796 defer func() {
11797 if r := recover(); r != nil {
11798 ec.Error(ctx, ec.Recover(ctx, r))
11799 ret = graphql.Null
11800 }
11801 }()
11802 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11803 ctx = rctx // use context from middleware stack in children
11804 return ec.resolvers.SetTitleOperation().ID(rctx, obj)
11805 })
11806 if err != nil {
11807 ec.Error(ctx, err)
11808 return graphql.Null
11809 }
11810 if resTmp == nil {
11811 if !graphql.HasFieldError(ctx, fc) {
11812 ec.Errorf(ctx, "must not be null")
11813 }
11814 return graphql.Null
11815 }
11816 res := resTmp.(string)
11817 fc.Result = res
11818 return ec.marshalNString2string(ctx, field.Selections, res)
11819}
11820
11821func (ec *executionContext) fieldContext_SetTitleOperation_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11822 fc = &graphql.FieldContext{
11823 Object: "SetTitleOperation",
11824 Field: field,
11825 IsMethod: true,
11826 IsResolver: true,
11827 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11828 return nil, errors.New("field of type String does not have child fields")
11829 },
11830 }
11831 return fc, nil
11832}
11833
11834func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
11835 fc, err := ec.fieldContext_SetTitleOperation_author(ctx, field)
11836 if err != nil {
11837 return graphql.Null
11838 }
11839 ctx = graphql.WithFieldContext(ctx, fc)
11840 defer func() {
11841 if r := recover(); r != nil {
11842 ec.Error(ctx, ec.Recover(ctx, r))
11843 ret = graphql.Null
11844 }
11845 }()
11846 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11847 ctx = rctx // use context from middleware stack in children
11848 return ec.resolvers.SetTitleOperation().Author(rctx, obj)
11849 })
11850 if err != nil {
11851 ec.Error(ctx, err)
11852 return graphql.Null
11853 }
11854 if resTmp == nil {
11855 if !graphql.HasFieldError(ctx, fc) {
11856 ec.Errorf(ctx, "must not be null")
11857 }
11858 return graphql.Null
11859 }
11860 res := resTmp.(models.IdentityWrapper)
11861 fc.Result = res
11862 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
11863}
11864
11865func (ec *executionContext) fieldContext_SetTitleOperation_author(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11866 fc = &graphql.FieldContext{
11867 Object: "SetTitleOperation",
11868 Field: field,
11869 IsMethod: true,
11870 IsResolver: true,
11871 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11872 switch field.Name {
11873 case "id":
11874 return ec.fieldContext_Identity_id(ctx, field)
11875 case "humanId":
11876 return ec.fieldContext_Identity_humanId(ctx, field)
11877 case "name":
11878 return ec.fieldContext_Identity_name(ctx, field)
11879 case "email":
11880 return ec.fieldContext_Identity_email(ctx, field)
11881 case "login":
11882 return ec.fieldContext_Identity_login(ctx, field)
11883 case "displayName":
11884 return ec.fieldContext_Identity_displayName(ctx, field)
11885 case "avatarUrl":
11886 return ec.fieldContext_Identity_avatarUrl(ctx, field)
11887 case "isProtected":
11888 return ec.fieldContext_Identity_isProtected(ctx, field)
11889 }
11890 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
11891 },
11892 }
11893 return fc, nil
11894}
11895
11896func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
11897 fc, err := ec.fieldContext_SetTitleOperation_date(ctx, field)
11898 if err != nil {
11899 return graphql.Null
11900 }
11901 ctx = graphql.WithFieldContext(ctx, fc)
11902 defer func() {
11903 if r := recover(); r != nil {
11904 ec.Error(ctx, ec.Recover(ctx, r))
11905 ret = graphql.Null
11906 }
11907 }()
11908 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11909 ctx = rctx // use context from middleware stack in children
11910 return ec.resolvers.SetTitleOperation().Date(rctx, obj)
11911 })
11912 if err != nil {
11913 ec.Error(ctx, err)
11914 return graphql.Null
11915 }
11916 if resTmp == nil {
11917 if !graphql.HasFieldError(ctx, fc) {
11918 ec.Errorf(ctx, "must not be null")
11919 }
11920 return graphql.Null
11921 }
11922 res := resTmp.(*time.Time)
11923 fc.Result = res
11924 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
11925}
11926
11927func (ec *executionContext) fieldContext_SetTitleOperation_date(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11928 fc = &graphql.FieldContext{
11929 Object: "SetTitleOperation",
11930 Field: field,
11931 IsMethod: true,
11932 IsResolver: true,
11933 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11934 return nil, errors.New("field of type Time does not have child fields")
11935 },
11936 }
11937 return fc, nil
11938}
11939
11940func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
11941 fc, err := ec.fieldContext_SetTitleOperation_title(ctx, field)
11942 if err != nil {
11943 return graphql.Null
11944 }
11945 ctx = graphql.WithFieldContext(ctx, fc)
11946 defer func() {
11947 if r := recover(); r != nil {
11948 ec.Error(ctx, ec.Recover(ctx, r))
11949 ret = graphql.Null
11950 }
11951 }()
11952 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11953 ctx = rctx // use context from middleware stack in children
11954 return obj.Title, nil
11955 })
11956 if err != nil {
11957 ec.Error(ctx, err)
11958 return graphql.Null
11959 }
11960 if resTmp == nil {
11961 if !graphql.HasFieldError(ctx, fc) {
11962 ec.Errorf(ctx, "must not be null")
11963 }
11964 return graphql.Null
11965 }
11966 res := resTmp.(string)
11967 fc.Result = res
11968 return ec.marshalNString2string(ctx, field.Selections, res)
11969}
11970
11971func (ec *executionContext) fieldContext_SetTitleOperation_title(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11972 fc = &graphql.FieldContext{
11973 Object: "SetTitleOperation",
11974 Field: field,
11975 IsMethod: false,
11976 IsResolver: false,
11977 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11978 return nil, errors.New("field of type String does not have child fields")
11979 },
11980 }
11981 return fc, nil
11982}
11983
11984func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
11985 fc, err := ec.fieldContext_SetTitleOperation_was(ctx, field)
11986 if err != nil {
11987 return graphql.Null
11988 }
11989 ctx = graphql.WithFieldContext(ctx, fc)
11990 defer func() {
11991 if r := recover(); r != nil {
11992 ec.Error(ctx, ec.Recover(ctx, r))
11993 ret = graphql.Null
11994 }
11995 }()
11996 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
11997 ctx = rctx // use context from middleware stack in children
11998 return obj.Was, nil
11999 })
12000 if err != nil {
12001 ec.Error(ctx, err)
12002 return graphql.Null
12003 }
12004 if resTmp == nil {
12005 if !graphql.HasFieldError(ctx, fc) {
12006 ec.Errorf(ctx, "must not be null")
12007 }
12008 return graphql.Null
12009 }
12010 res := resTmp.(string)
12011 fc.Result = res
12012 return ec.marshalNString2string(ctx, field.Selections, res)
12013}
12014
12015func (ec *executionContext) fieldContext_SetTitleOperation_was(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12016 fc = &graphql.FieldContext{
12017 Object: "SetTitleOperation",
12018 Field: field,
12019 IsMethod: false,
12020 IsResolver: false,
12021 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12022 return nil, errors.New("field of type String does not have child fields")
12023 },
12024 }
12025 return fc, nil
12026}
12027
12028func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
12029 fc, err := ec.fieldContext_SetTitlePayload_clientMutationId(ctx, field)
12030 if err != nil {
12031 return graphql.Null
12032 }
12033 ctx = graphql.WithFieldContext(ctx, fc)
12034 defer func() {
12035 if r := recover(); r != nil {
12036 ec.Error(ctx, ec.Recover(ctx, r))
12037 ret = graphql.Null
12038 }
12039 }()
12040 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12041 ctx = rctx // use context from middleware stack in children
12042 return obj.ClientMutationID, nil
12043 })
12044 if err != nil {
12045 ec.Error(ctx, err)
12046 return graphql.Null
12047 }
12048 if resTmp == nil {
12049 return graphql.Null
12050 }
12051 res := resTmp.(*string)
12052 fc.Result = res
12053 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
12054}
12055
12056func (ec *executionContext) fieldContext_SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12057 fc = &graphql.FieldContext{
12058 Object: "SetTitlePayload",
12059 Field: field,
12060 IsMethod: false,
12061 IsResolver: false,
12062 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12063 return nil, errors.New("field of type String does not have child fields")
12064 },
12065 }
12066 return fc, nil
12067}
12068
12069func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
12070 fc, err := ec.fieldContext_SetTitlePayload_bug(ctx, field)
12071 if err != nil {
12072 return graphql.Null
12073 }
12074 ctx = graphql.WithFieldContext(ctx, fc)
12075 defer func() {
12076 if r := recover(); r != nil {
12077 ec.Error(ctx, ec.Recover(ctx, r))
12078 ret = graphql.Null
12079 }
12080 }()
12081 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12082 ctx = rctx // use context from middleware stack in children
12083 return obj.Bug, nil
12084 })
12085 if err != nil {
12086 ec.Error(ctx, err)
12087 return graphql.Null
12088 }
12089 if resTmp == nil {
12090 if !graphql.HasFieldError(ctx, fc) {
12091 ec.Errorf(ctx, "must not be null")
12092 }
12093 return graphql.Null
12094 }
12095 res := resTmp.(models.BugWrapper)
12096 fc.Result = res
12097 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
12098}
12099
12100func (ec *executionContext) fieldContext_SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12101 fc = &graphql.FieldContext{
12102 Object: "SetTitlePayload",
12103 Field: field,
12104 IsMethod: false,
12105 IsResolver: false,
12106 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12107 switch field.Name {
12108 case "id":
12109 return ec.fieldContext_Bug_id(ctx, field)
12110 case "humanId":
12111 return ec.fieldContext_Bug_humanId(ctx, field)
12112 case "status":
12113 return ec.fieldContext_Bug_status(ctx, field)
12114 case "title":
12115 return ec.fieldContext_Bug_title(ctx, field)
12116 case "labels":
12117 return ec.fieldContext_Bug_labels(ctx, field)
12118 case "author":
12119 return ec.fieldContext_Bug_author(ctx, field)
12120 case "createdAt":
12121 return ec.fieldContext_Bug_createdAt(ctx, field)
12122 case "lastEdit":
12123 return ec.fieldContext_Bug_lastEdit(ctx, field)
12124 case "actors":
12125 return ec.fieldContext_Bug_actors(ctx, field)
12126 case "participants":
12127 return ec.fieldContext_Bug_participants(ctx, field)
12128 case "comments":
12129 return ec.fieldContext_Bug_comments(ctx, field)
12130 case "timeline":
12131 return ec.fieldContext_Bug_timeline(ctx, field)
12132 case "operations":
12133 return ec.fieldContext_Bug_operations(ctx, field)
12134 }
12135 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
12136 },
12137 }
12138 return fc, nil
12139}
12140
12141func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
12142 fc, err := ec.fieldContext_SetTitlePayload_operation(ctx, field)
12143 if err != nil {
12144 return graphql.Null
12145 }
12146 ctx = graphql.WithFieldContext(ctx, fc)
12147 defer func() {
12148 if r := recover(); r != nil {
12149 ec.Error(ctx, ec.Recover(ctx, r))
12150 ret = graphql.Null
12151 }
12152 }()
12153 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12154 ctx = rctx // use context from middleware stack in children
12155 return obj.Operation, nil
12156 })
12157 if err != nil {
12158 ec.Error(ctx, err)
12159 return graphql.Null
12160 }
12161 if resTmp == nil {
12162 if !graphql.HasFieldError(ctx, fc) {
12163 ec.Errorf(ctx, "must not be null")
12164 }
12165 return graphql.Null
12166 }
12167 res := resTmp.(*bug.SetTitleOperation)
12168 fc.Result = res
12169 return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
12170}
12171
12172func (ec *executionContext) fieldContext_SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12173 fc = &graphql.FieldContext{
12174 Object: "SetTitlePayload",
12175 Field: field,
12176 IsMethod: false,
12177 IsResolver: false,
12178 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12179 switch field.Name {
12180 case "id":
12181 return ec.fieldContext_SetTitleOperation_id(ctx, field)
12182 case "author":
12183 return ec.fieldContext_SetTitleOperation_author(ctx, field)
12184 case "date":
12185 return ec.fieldContext_SetTitleOperation_date(ctx, field)
12186 case "title":
12187 return ec.fieldContext_SetTitleOperation_title(ctx, field)
12188 case "was":
12189 return ec.fieldContext_SetTitleOperation_was(ctx, field)
12190 }
12191 return nil, fmt.Errorf("no field named %q was found under type SetTitleOperation", field.Name)
12192 },
12193 }
12194 return fc, nil
12195}
12196
12197func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
12198 fc, err := ec.fieldContext_SetTitleTimelineItem_id(ctx, field)
12199 if err != nil {
12200 return graphql.Null
12201 }
12202 ctx = graphql.WithFieldContext(ctx, fc)
12203 defer func() {
12204 if r := recover(); r != nil {
12205 ec.Error(ctx, ec.Recover(ctx, r))
12206 ret = graphql.Null
12207 }
12208 }()
12209 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12210 ctx = rctx // use context from middleware stack in children
12211 return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
12212 })
12213 if err != nil {
12214 ec.Error(ctx, err)
12215 return graphql.Null
12216 }
12217 if resTmp == nil {
12218 if !graphql.HasFieldError(ctx, fc) {
12219 ec.Errorf(ctx, "must not be null")
12220 }
12221 return graphql.Null
12222 }
12223 res := resTmp.(string)
12224 fc.Result = res
12225 return ec.marshalNString2string(ctx, field.Selections, res)
12226}
12227
12228func (ec *executionContext) fieldContext_SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12229 fc = &graphql.FieldContext{
12230 Object: "SetTitleTimelineItem",
12231 Field: field,
12232 IsMethod: true,
12233 IsResolver: true,
12234 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12235 return nil, errors.New("field of type String does not have child fields")
12236 },
12237 }
12238 return fc, nil
12239}
12240
12241func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
12242 fc, err := ec.fieldContext_SetTitleTimelineItem_author(ctx, field)
12243 if err != nil {
12244 return graphql.Null
12245 }
12246 ctx = graphql.WithFieldContext(ctx, fc)
12247 defer func() {
12248 if r := recover(); r != nil {
12249 ec.Error(ctx, ec.Recover(ctx, r))
12250 ret = graphql.Null
12251 }
12252 }()
12253 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12254 ctx = rctx // use context from middleware stack in children
12255 return ec.resolvers.SetTitleTimelineItem().Author(rctx, obj)
12256 })
12257 if err != nil {
12258 ec.Error(ctx, err)
12259 return graphql.Null
12260 }
12261 if resTmp == nil {
12262 if !graphql.HasFieldError(ctx, fc) {
12263 ec.Errorf(ctx, "must not be null")
12264 }
12265 return graphql.Null
12266 }
12267 res := resTmp.(models.IdentityWrapper)
12268 fc.Result = res
12269 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
12270}
12271
12272func (ec *executionContext) fieldContext_SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12273 fc = &graphql.FieldContext{
12274 Object: "SetTitleTimelineItem",
12275 Field: field,
12276 IsMethod: true,
12277 IsResolver: true,
12278 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12279 switch field.Name {
12280 case "id":
12281 return ec.fieldContext_Identity_id(ctx, field)
12282 case "humanId":
12283 return ec.fieldContext_Identity_humanId(ctx, field)
12284 case "name":
12285 return ec.fieldContext_Identity_name(ctx, field)
12286 case "email":
12287 return ec.fieldContext_Identity_email(ctx, field)
12288 case "login":
12289 return ec.fieldContext_Identity_login(ctx, field)
12290 case "displayName":
12291 return ec.fieldContext_Identity_displayName(ctx, field)
12292 case "avatarUrl":
12293 return ec.fieldContext_Identity_avatarUrl(ctx, field)
12294 case "isProtected":
12295 return ec.fieldContext_Identity_isProtected(ctx, field)
12296 }
12297 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
12298 },
12299 }
12300 return fc, nil
12301}
12302
12303func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
12304 fc, err := ec.fieldContext_SetTitleTimelineItem_date(ctx, field)
12305 if err != nil {
12306 return graphql.Null
12307 }
12308 ctx = graphql.WithFieldContext(ctx, fc)
12309 defer func() {
12310 if r := recover(); r != nil {
12311 ec.Error(ctx, ec.Recover(ctx, r))
12312 ret = graphql.Null
12313 }
12314 }()
12315 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12316 ctx = rctx // use context from middleware stack in children
12317 return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
12318 })
12319 if err != nil {
12320 ec.Error(ctx, err)
12321 return graphql.Null
12322 }
12323 if resTmp == nil {
12324 if !graphql.HasFieldError(ctx, fc) {
12325 ec.Errorf(ctx, "must not be null")
12326 }
12327 return graphql.Null
12328 }
12329 res := resTmp.(*time.Time)
12330 fc.Result = res
12331 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
12332}
12333
12334func (ec *executionContext) fieldContext_SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12335 fc = &graphql.FieldContext{
12336 Object: "SetTitleTimelineItem",
12337 Field: field,
12338 IsMethod: true,
12339 IsResolver: true,
12340 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12341 return nil, errors.New("field of type Time does not have child fields")
12342 },
12343 }
12344 return fc, nil
12345}
12346
12347func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
12348 fc, err := ec.fieldContext_SetTitleTimelineItem_title(ctx, field)
12349 if err != nil {
12350 return graphql.Null
12351 }
12352 ctx = graphql.WithFieldContext(ctx, fc)
12353 defer func() {
12354 if r := recover(); r != nil {
12355 ec.Error(ctx, ec.Recover(ctx, r))
12356 ret = graphql.Null
12357 }
12358 }()
12359 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12360 ctx = rctx // use context from middleware stack in children
12361 return obj.Title, nil
12362 })
12363 if err != nil {
12364 ec.Error(ctx, err)
12365 return graphql.Null
12366 }
12367 if resTmp == nil {
12368 if !graphql.HasFieldError(ctx, fc) {
12369 ec.Errorf(ctx, "must not be null")
12370 }
12371 return graphql.Null
12372 }
12373 res := resTmp.(string)
12374 fc.Result = res
12375 return ec.marshalNString2string(ctx, field.Selections, res)
12376}
12377
12378func (ec *executionContext) fieldContext_SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12379 fc = &graphql.FieldContext{
12380 Object: "SetTitleTimelineItem",
12381 Field: field,
12382 IsMethod: false,
12383 IsResolver: false,
12384 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12385 return nil, errors.New("field of type String does not have child fields")
12386 },
12387 }
12388 return fc, nil
12389}
12390
12391func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
12392 fc, err := ec.fieldContext_SetTitleTimelineItem_was(ctx, field)
12393 if err != nil {
12394 return graphql.Null
12395 }
12396 ctx = graphql.WithFieldContext(ctx, fc)
12397 defer func() {
12398 if r := recover(); r != nil {
12399 ec.Error(ctx, ec.Recover(ctx, r))
12400 ret = graphql.Null
12401 }
12402 }()
12403 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12404 ctx = rctx // use context from middleware stack in children
12405 return obj.Was, nil
12406 })
12407 if err != nil {
12408 ec.Error(ctx, err)
12409 return graphql.Null
12410 }
12411 if resTmp == nil {
12412 if !graphql.HasFieldError(ctx, fc) {
12413 ec.Errorf(ctx, "must not be null")
12414 }
12415 return graphql.Null
12416 }
12417 res := resTmp.(string)
12418 fc.Result = res
12419 return ec.marshalNString2string(ctx, field.Selections, res)
12420}
12421
12422func (ec *executionContext) fieldContext_SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12423 fc = &graphql.FieldContext{
12424 Object: "SetTitleTimelineItem",
12425 Field: field,
12426 IsMethod: false,
12427 IsResolver: false,
12428 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12429 return nil, errors.New("field of type String does not have child fields")
12430 },
12431 }
12432 return fc, nil
12433}
12434
12435func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
12436 fc, err := ec.fieldContext_TimelineItemConnection_edges(ctx, field)
12437 if err != nil {
12438 return graphql.Null
12439 }
12440 ctx = graphql.WithFieldContext(ctx, fc)
12441 defer func() {
12442 if r := recover(); r != nil {
12443 ec.Error(ctx, ec.Recover(ctx, r))
12444 ret = graphql.Null
12445 }
12446 }()
12447 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12448 ctx = rctx // use context from middleware stack in children
12449 return obj.Edges, nil
12450 })
12451 if err != nil {
12452 ec.Error(ctx, err)
12453 return graphql.Null
12454 }
12455 if resTmp == nil {
12456 if !graphql.HasFieldError(ctx, fc) {
12457 ec.Errorf(ctx, "must not be null")
12458 }
12459 return graphql.Null
12460 }
12461 res := resTmp.([]*models.TimelineItemEdge)
12462 fc.Result = res
12463 return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx, field.Selections, res)
12464}
12465
12466func (ec *executionContext) fieldContext_TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12467 fc = &graphql.FieldContext{
12468 Object: "TimelineItemConnection",
12469 Field: field,
12470 IsMethod: false,
12471 IsResolver: false,
12472 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12473 switch field.Name {
12474 case "cursor":
12475 return ec.fieldContext_TimelineItemEdge_cursor(ctx, field)
12476 case "node":
12477 return ec.fieldContext_TimelineItemEdge_node(ctx, field)
12478 }
12479 return nil, fmt.Errorf("no field named %q was found under type TimelineItemEdge", field.Name)
12480 },
12481 }
12482 return fc, nil
12483}
12484
12485func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
12486 fc, err := ec.fieldContext_TimelineItemConnection_nodes(ctx, field)
12487 if err != nil {
12488 return graphql.Null
12489 }
12490 ctx = graphql.WithFieldContext(ctx, fc)
12491 defer func() {
12492 if r := recover(); r != nil {
12493 ec.Error(ctx, ec.Recover(ctx, r))
12494 ret = graphql.Null
12495 }
12496 }()
12497 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12498 ctx = rctx // use context from middleware stack in children
12499 return obj.Nodes, nil
12500 })
12501 if err != nil {
12502 ec.Error(ctx, err)
12503 return graphql.Null
12504 }
12505 if resTmp == nil {
12506 if !graphql.HasFieldError(ctx, fc) {
12507 ec.Errorf(ctx, "must not be null")
12508 }
12509 return graphql.Null
12510 }
12511 res := resTmp.([]bug.TimelineItem)
12512 fc.Result = res
12513 return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx, field.Selections, res)
12514}
12515
12516func (ec *executionContext) fieldContext_TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12517 fc = &graphql.FieldContext{
12518 Object: "TimelineItemConnection",
12519 Field: field,
12520 IsMethod: false,
12521 IsResolver: false,
12522 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12523 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
12524 },
12525 }
12526 return fc, nil
12527}
12528
12529func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
12530 fc, err := ec.fieldContext_TimelineItemConnection_pageInfo(ctx, field)
12531 if err != nil {
12532 return graphql.Null
12533 }
12534 ctx = graphql.WithFieldContext(ctx, fc)
12535 defer func() {
12536 if r := recover(); r != nil {
12537 ec.Error(ctx, ec.Recover(ctx, r))
12538 ret = graphql.Null
12539 }
12540 }()
12541 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12542 ctx = rctx // use context from middleware stack in children
12543 return obj.PageInfo, nil
12544 })
12545 if err != nil {
12546 ec.Error(ctx, err)
12547 return graphql.Null
12548 }
12549 if resTmp == nil {
12550 if !graphql.HasFieldError(ctx, fc) {
12551 ec.Errorf(ctx, "must not be null")
12552 }
12553 return graphql.Null
12554 }
12555 res := resTmp.(*models.PageInfo)
12556 fc.Result = res
12557 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
12558}
12559
12560func (ec *executionContext) fieldContext_TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12561 fc = &graphql.FieldContext{
12562 Object: "TimelineItemConnection",
12563 Field: field,
12564 IsMethod: false,
12565 IsResolver: false,
12566 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12567 switch field.Name {
12568 case "hasNextPage":
12569 return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
12570 case "hasPreviousPage":
12571 return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
12572 case "startCursor":
12573 return ec.fieldContext_PageInfo_startCursor(ctx, field)
12574 case "endCursor":
12575 return ec.fieldContext_PageInfo_endCursor(ctx, field)
12576 }
12577 return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
12578 },
12579 }
12580 return fc, nil
12581}
12582
12583func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
12584 fc, err := ec.fieldContext_TimelineItemConnection_totalCount(ctx, field)
12585 if err != nil {
12586 return graphql.Null
12587 }
12588 ctx = graphql.WithFieldContext(ctx, fc)
12589 defer func() {
12590 if r := recover(); r != nil {
12591 ec.Error(ctx, ec.Recover(ctx, r))
12592 ret = graphql.Null
12593 }
12594 }()
12595 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12596 ctx = rctx // use context from middleware stack in children
12597 return obj.TotalCount, nil
12598 })
12599 if err != nil {
12600 ec.Error(ctx, err)
12601 return graphql.Null
12602 }
12603 if resTmp == nil {
12604 if !graphql.HasFieldError(ctx, fc) {
12605 ec.Errorf(ctx, "must not be null")
12606 }
12607 return graphql.Null
12608 }
12609 res := resTmp.(int)
12610 fc.Result = res
12611 return ec.marshalNInt2int(ctx, field.Selections, res)
12612}
12613
12614func (ec *executionContext) fieldContext_TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12615 fc = &graphql.FieldContext{
12616 Object: "TimelineItemConnection",
12617 Field: field,
12618 IsMethod: false,
12619 IsResolver: false,
12620 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12621 return nil, errors.New("field of type Int does not have child fields")
12622 },
12623 }
12624 return fc, nil
12625}
12626
12627func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
12628 fc, err := ec.fieldContext_TimelineItemEdge_cursor(ctx, field)
12629 if err != nil {
12630 return graphql.Null
12631 }
12632 ctx = graphql.WithFieldContext(ctx, fc)
12633 defer func() {
12634 if r := recover(); r != nil {
12635 ec.Error(ctx, ec.Recover(ctx, r))
12636 ret = graphql.Null
12637 }
12638 }()
12639 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12640 ctx = rctx // use context from middleware stack in children
12641 return obj.Cursor, nil
12642 })
12643 if err != nil {
12644 ec.Error(ctx, err)
12645 return graphql.Null
12646 }
12647 if resTmp == nil {
12648 if !graphql.HasFieldError(ctx, fc) {
12649 ec.Errorf(ctx, "must not be null")
12650 }
12651 return graphql.Null
12652 }
12653 res := resTmp.(string)
12654 fc.Result = res
12655 return ec.marshalNString2string(ctx, field.Selections, res)
12656}
12657
12658func (ec *executionContext) fieldContext_TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12659 fc = &graphql.FieldContext{
12660 Object: "TimelineItemEdge",
12661 Field: field,
12662 IsMethod: false,
12663 IsResolver: false,
12664 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12665 return nil, errors.New("field of type String does not have child fields")
12666 },
12667 }
12668 return fc, nil
12669}
12670
12671func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
12672 fc, err := ec.fieldContext_TimelineItemEdge_node(ctx, field)
12673 if err != nil {
12674 return graphql.Null
12675 }
12676 ctx = graphql.WithFieldContext(ctx, fc)
12677 defer func() {
12678 if r := recover(); r != nil {
12679 ec.Error(ctx, ec.Recover(ctx, r))
12680 ret = graphql.Null
12681 }
12682 }()
12683 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12684 ctx = rctx // use context from middleware stack in children
12685 return obj.Node, nil
12686 })
12687 if err != nil {
12688 ec.Error(ctx, err)
12689 return graphql.Null
12690 }
12691 if resTmp == nil {
12692 if !graphql.HasFieldError(ctx, fc) {
12693 ec.Errorf(ctx, "must not be null")
12694 }
12695 return graphql.Null
12696 }
12697 res := resTmp.(bug.TimelineItem)
12698 fc.Result = res
12699 return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
12700}
12701
12702func (ec *executionContext) fieldContext_TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12703 fc = &graphql.FieldContext{
12704 Object: "TimelineItemEdge",
12705 Field: field,
12706 IsMethod: false,
12707 IsResolver: false,
12708 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12709 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
12710 },
12711 }
12712 return fc, nil
12713}
12714
12715func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
12716 fc, err := ec.fieldContext___Directive_name(ctx, field)
12717 if err != nil {
12718 return graphql.Null
12719 }
12720 ctx = graphql.WithFieldContext(ctx, fc)
12721 defer func() {
12722 if r := recover(); r != nil {
12723 ec.Error(ctx, ec.Recover(ctx, r))
12724 ret = graphql.Null
12725 }
12726 }()
12727 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12728 ctx = rctx // use context from middleware stack in children
12729 return obj.Name, nil
12730 })
12731 if err != nil {
12732 ec.Error(ctx, err)
12733 return graphql.Null
12734 }
12735 if resTmp == nil {
12736 if !graphql.HasFieldError(ctx, fc) {
12737 ec.Errorf(ctx, "must not be null")
12738 }
12739 return graphql.Null
12740 }
12741 res := resTmp.(string)
12742 fc.Result = res
12743 return ec.marshalNString2string(ctx, field.Selections, res)
12744}
12745
12746func (ec *executionContext) fieldContext___Directive_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12747 fc = &graphql.FieldContext{
12748 Object: "__Directive",
12749 Field: field,
12750 IsMethod: false,
12751 IsResolver: false,
12752 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12753 return nil, errors.New("field of type String does not have child fields")
12754 },
12755 }
12756 return fc, nil
12757}
12758
12759func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
12760 fc, err := ec.fieldContext___Directive_description(ctx, field)
12761 if err != nil {
12762 return graphql.Null
12763 }
12764 ctx = graphql.WithFieldContext(ctx, fc)
12765 defer func() {
12766 if r := recover(); r != nil {
12767 ec.Error(ctx, ec.Recover(ctx, r))
12768 ret = graphql.Null
12769 }
12770 }()
12771 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12772 ctx = rctx // use context from middleware stack in children
12773 return obj.Description(), nil
12774 })
12775 if err != nil {
12776 ec.Error(ctx, err)
12777 return graphql.Null
12778 }
12779 if resTmp == nil {
12780 return graphql.Null
12781 }
12782 res := resTmp.(*string)
12783 fc.Result = res
12784 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
12785}
12786
12787func (ec *executionContext) fieldContext___Directive_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12788 fc = &graphql.FieldContext{
12789 Object: "__Directive",
12790 Field: field,
12791 IsMethod: true,
12792 IsResolver: false,
12793 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12794 return nil, errors.New("field of type String does not have child fields")
12795 },
12796 }
12797 return fc, nil
12798}
12799
12800func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
12801 fc, err := ec.fieldContext___Directive_locations(ctx, field)
12802 if err != nil {
12803 return graphql.Null
12804 }
12805 ctx = graphql.WithFieldContext(ctx, fc)
12806 defer func() {
12807 if r := recover(); r != nil {
12808 ec.Error(ctx, ec.Recover(ctx, r))
12809 ret = graphql.Null
12810 }
12811 }()
12812 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12813 ctx = rctx // use context from middleware stack in children
12814 return obj.Locations, nil
12815 })
12816 if err != nil {
12817 ec.Error(ctx, err)
12818 return graphql.Null
12819 }
12820 if resTmp == nil {
12821 if !graphql.HasFieldError(ctx, fc) {
12822 ec.Errorf(ctx, "must not be null")
12823 }
12824 return graphql.Null
12825 }
12826 res := resTmp.([]string)
12827 fc.Result = res
12828 return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
12829}
12830
12831func (ec *executionContext) fieldContext___Directive_locations(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12832 fc = &graphql.FieldContext{
12833 Object: "__Directive",
12834 Field: field,
12835 IsMethod: false,
12836 IsResolver: false,
12837 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12838 return nil, errors.New("field of type __DirectiveLocation does not have child fields")
12839 },
12840 }
12841 return fc, nil
12842}
12843
12844func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
12845 fc, err := ec.fieldContext___Directive_args(ctx, field)
12846 if err != nil {
12847 return graphql.Null
12848 }
12849 ctx = graphql.WithFieldContext(ctx, fc)
12850 defer func() {
12851 if r := recover(); r != nil {
12852 ec.Error(ctx, ec.Recover(ctx, r))
12853 ret = graphql.Null
12854 }
12855 }()
12856 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12857 ctx = rctx // use context from middleware stack in children
12858 return obj.Args, nil
12859 })
12860 if err != nil {
12861 ec.Error(ctx, err)
12862 return graphql.Null
12863 }
12864 if resTmp == nil {
12865 if !graphql.HasFieldError(ctx, fc) {
12866 ec.Errorf(ctx, "must not be null")
12867 }
12868 return graphql.Null
12869 }
12870 res := resTmp.([]introspection.InputValue)
12871 fc.Result = res
12872 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
12873}
12874
12875func (ec *executionContext) fieldContext___Directive_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12876 fc = &graphql.FieldContext{
12877 Object: "__Directive",
12878 Field: field,
12879 IsMethod: false,
12880 IsResolver: false,
12881 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12882 switch field.Name {
12883 case "name":
12884 return ec.fieldContext___InputValue_name(ctx, field)
12885 case "description":
12886 return ec.fieldContext___InputValue_description(ctx, field)
12887 case "type":
12888 return ec.fieldContext___InputValue_type(ctx, field)
12889 case "defaultValue":
12890 return ec.fieldContext___InputValue_defaultValue(ctx, field)
12891 }
12892 return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
12893 },
12894 }
12895 return fc, nil
12896}
12897
12898func (ec *executionContext) ___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
12899 fc, err := ec.fieldContext___Directive_isRepeatable(ctx, field)
12900 if err != nil {
12901 return graphql.Null
12902 }
12903 ctx = graphql.WithFieldContext(ctx, fc)
12904 defer func() {
12905 if r := recover(); r != nil {
12906 ec.Error(ctx, ec.Recover(ctx, r))
12907 ret = graphql.Null
12908 }
12909 }()
12910 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12911 ctx = rctx // use context from middleware stack in children
12912 return obj.IsRepeatable, nil
12913 })
12914 if err != nil {
12915 ec.Error(ctx, err)
12916 return graphql.Null
12917 }
12918 if resTmp == nil {
12919 if !graphql.HasFieldError(ctx, fc) {
12920 ec.Errorf(ctx, "must not be null")
12921 }
12922 return graphql.Null
12923 }
12924 res := resTmp.(bool)
12925 fc.Result = res
12926 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
12927}
12928
12929func (ec *executionContext) fieldContext___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12930 fc = &graphql.FieldContext{
12931 Object: "__Directive",
12932 Field: field,
12933 IsMethod: false,
12934 IsResolver: false,
12935 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12936 return nil, errors.New("field of type Boolean does not have child fields")
12937 },
12938 }
12939 return fc, nil
12940}
12941
12942func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
12943 fc, err := ec.fieldContext___EnumValue_name(ctx, field)
12944 if err != nil {
12945 return graphql.Null
12946 }
12947 ctx = graphql.WithFieldContext(ctx, fc)
12948 defer func() {
12949 if r := recover(); r != nil {
12950 ec.Error(ctx, ec.Recover(ctx, r))
12951 ret = graphql.Null
12952 }
12953 }()
12954 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12955 ctx = rctx // use context from middleware stack in children
12956 return obj.Name, nil
12957 })
12958 if err != nil {
12959 ec.Error(ctx, err)
12960 return graphql.Null
12961 }
12962 if resTmp == nil {
12963 if !graphql.HasFieldError(ctx, fc) {
12964 ec.Errorf(ctx, "must not be null")
12965 }
12966 return graphql.Null
12967 }
12968 res := resTmp.(string)
12969 fc.Result = res
12970 return ec.marshalNString2string(ctx, field.Selections, res)
12971}
12972
12973func (ec *executionContext) fieldContext___EnumValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12974 fc = &graphql.FieldContext{
12975 Object: "__EnumValue",
12976 Field: field,
12977 IsMethod: false,
12978 IsResolver: false,
12979 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12980 return nil, errors.New("field of type String does not have child fields")
12981 },
12982 }
12983 return fc, nil
12984}
12985
12986func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
12987 fc, err := ec.fieldContext___EnumValue_description(ctx, field)
12988 if err != nil {
12989 return graphql.Null
12990 }
12991 ctx = graphql.WithFieldContext(ctx, fc)
12992 defer func() {
12993 if r := recover(); r != nil {
12994 ec.Error(ctx, ec.Recover(ctx, r))
12995 ret = graphql.Null
12996 }
12997 }()
12998 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
12999 ctx = rctx // use context from middleware stack in children
13000 return obj.Description(), nil
13001 })
13002 if err != nil {
13003 ec.Error(ctx, err)
13004 return graphql.Null
13005 }
13006 if resTmp == nil {
13007 return graphql.Null
13008 }
13009 res := resTmp.(*string)
13010 fc.Result = res
13011 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
13012}
13013
13014func (ec *executionContext) fieldContext___EnumValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13015 fc = &graphql.FieldContext{
13016 Object: "__EnumValue",
13017 Field: field,
13018 IsMethod: true,
13019 IsResolver: false,
13020 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13021 return nil, errors.New("field of type String does not have child fields")
13022 },
13023 }
13024 return fc, nil
13025}
13026
13027func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
13028 fc, err := ec.fieldContext___EnumValue_isDeprecated(ctx, field)
13029 if err != nil {
13030 return graphql.Null
13031 }
13032 ctx = graphql.WithFieldContext(ctx, fc)
13033 defer func() {
13034 if r := recover(); r != nil {
13035 ec.Error(ctx, ec.Recover(ctx, r))
13036 ret = graphql.Null
13037 }
13038 }()
13039 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13040 ctx = rctx // use context from middleware stack in children
13041 return obj.IsDeprecated(), nil
13042 })
13043 if err != nil {
13044 ec.Error(ctx, err)
13045 return graphql.Null
13046 }
13047 if resTmp == nil {
13048 if !graphql.HasFieldError(ctx, fc) {
13049 ec.Errorf(ctx, "must not be null")
13050 }
13051 return graphql.Null
13052 }
13053 res := resTmp.(bool)
13054 fc.Result = res
13055 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
13056}
13057
13058func (ec *executionContext) fieldContext___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13059 fc = &graphql.FieldContext{
13060 Object: "__EnumValue",
13061 Field: field,
13062 IsMethod: true,
13063 IsResolver: false,
13064 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13065 return nil, errors.New("field of type Boolean does not have child fields")
13066 },
13067 }
13068 return fc, nil
13069}
13070
13071func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
13072 fc, err := ec.fieldContext___EnumValue_deprecationReason(ctx, field)
13073 if err != nil {
13074 return graphql.Null
13075 }
13076 ctx = graphql.WithFieldContext(ctx, fc)
13077 defer func() {
13078 if r := recover(); r != nil {
13079 ec.Error(ctx, ec.Recover(ctx, r))
13080 ret = graphql.Null
13081 }
13082 }()
13083 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13084 ctx = rctx // use context from middleware stack in children
13085 return obj.DeprecationReason(), nil
13086 })
13087 if err != nil {
13088 ec.Error(ctx, err)
13089 return graphql.Null
13090 }
13091 if resTmp == nil {
13092 return graphql.Null
13093 }
13094 res := resTmp.(*string)
13095 fc.Result = res
13096 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
13097}
13098
13099func (ec *executionContext) fieldContext___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13100 fc = &graphql.FieldContext{
13101 Object: "__EnumValue",
13102 Field: field,
13103 IsMethod: true,
13104 IsResolver: false,
13105 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13106 return nil, errors.New("field of type String does not have child fields")
13107 },
13108 }
13109 return fc, nil
13110}
13111
13112func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
13113 fc, err := ec.fieldContext___Field_name(ctx, field)
13114 if err != nil {
13115 return graphql.Null
13116 }
13117 ctx = graphql.WithFieldContext(ctx, fc)
13118 defer func() {
13119 if r := recover(); r != nil {
13120 ec.Error(ctx, ec.Recover(ctx, r))
13121 ret = graphql.Null
13122 }
13123 }()
13124 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13125 ctx = rctx // use context from middleware stack in children
13126 return obj.Name, nil
13127 })
13128 if err != nil {
13129 ec.Error(ctx, err)
13130 return graphql.Null
13131 }
13132 if resTmp == nil {
13133 if !graphql.HasFieldError(ctx, fc) {
13134 ec.Errorf(ctx, "must not be null")
13135 }
13136 return graphql.Null
13137 }
13138 res := resTmp.(string)
13139 fc.Result = res
13140 return ec.marshalNString2string(ctx, field.Selections, res)
13141}
13142
13143func (ec *executionContext) fieldContext___Field_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13144 fc = &graphql.FieldContext{
13145 Object: "__Field",
13146 Field: field,
13147 IsMethod: false,
13148 IsResolver: false,
13149 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13150 return nil, errors.New("field of type String does not have child fields")
13151 },
13152 }
13153 return fc, nil
13154}
13155
13156func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
13157 fc, err := ec.fieldContext___Field_description(ctx, field)
13158 if err != nil {
13159 return graphql.Null
13160 }
13161 ctx = graphql.WithFieldContext(ctx, fc)
13162 defer func() {
13163 if r := recover(); r != nil {
13164 ec.Error(ctx, ec.Recover(ctx, r))
13165 ret = graphql.Null
13166 }
13167 }()
13168 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13169 ctx = rctx // use context from middleware stack in children
13170 return obj.Description(), nil
13171 })
13172 if err != nil {
13173 ec.Error(ctx, err)
13174 return graphql.Null
13175 }
13176 if resTmp == nil {
13177 return graphql.Null
13178 }
13179 res := resTmp.(*string)
13180 fc.Result = res
13181 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
13182}
13183
13184func (ec *executionContext) fieldContext___Field_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13185 fc = &graphql.FieldContext{
13186 Object: "__Field",
13187 Field: field,
13188 IsMethod: true,
13189 IsResolver: false,
13190 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13191 return nil, errors.New("field of type String does not have child fields")
13192 },
13193 }
13194 return fc, nil
13195}
13196
13197func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
13198 fc, err := ec.fieldContext___Field_args(ctx, field)
13199 if err != nil {
13200 return graphql.Null
13201 }
13202 ctx = graphql.WithFieldContext(ctx, fc)
13203 defer func() {
13204 if r := recover(); r != nil {
13205 ec.Error(ctx, ec.Recover(ctx, r))
13206 ret = graphql.Null
13207 }
13208 }()
13209 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13210 ctx = rctx // use context from middleware stack in children
13211 return obj.Args, nil
13212 })
13213 if err != nil {
13214 ec.Error(ctx, err)
13215 return graphql.Null
13216 }
13217 if resTmp == nil {
13218 if !graphql.HasFieldError(ctx, fc) {
13219 ec.Errorf(ctx, "must not be null")
13220 }
13221 return graphql.Null
13222 }
13223 res := resTmp.([]introspection.InputValue)
13224 fc.Result = res
13225 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
13226}
13227
13228func (ec *executionContext) fieldContext___Field_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13229 fc = &graphql.FieldContext{
13230 Object: "__Field",
13231 Field: field,
13232 IsMethod: false,
13233 IsResolver: false,
13234 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13235 switch field.Name {
13236 case "name":
13237 return ec.fieldContext___InputValue_name(ctx, field)
13238 case "description":
13239 return ec.fieldContext___InputValue_description(ctx, field)
13240 case "type":
13241 return ec.fieldContext___InputValue_type(ctx, field)
13242 case "defaultValue":
13243 return ec.fieldContext___InputValue_defaultValue(ctx, field)
13244 }
13245 return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
13246 },
13247 }
13248 return fc, nil
13249}
13250
13251func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
13252 fc, err := ec.fieldContext___Field_type(ctx, field)
13253 if err != nil {
13254 return graphql.Null
13255 }
13256 ctx = graphql.WithFieldContext(ctx, fc)
13257 defer func() {
13258 if r := recover(); r != nil {
13259 ec.Error(ctx, ec.Recover(ctx, r))
13260 ret = graphql.Null
13261 }
13262 }()
13263 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13264 ctx = rctx // use context from middleware stack in children
13265 return obj.Type, nil
13266 })
13267 if err != nil {
13268 ec.Error(ctx, err)
13269 return graphql.Null
13270 }
13271 if resTmp == nil {
13272 if !graphql.HasFieldError(ctx, fc) {
13273 ec.Errorf(ctx, "must not be null")
13274 }
13275 return graphql.Null
13276 }
13277 res := resTmp.(*introspection.Type)
13278 fc.Result = res
13279 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
13280}
13281
13282func (ec *executionContext) fieldContext___Field_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13283 fc = &graphql.FieldContext{
13284 Object: "__Field",
13285 Field: field,
13286 IsMethod: false,
13287 IsResolver: false,
13288 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13289 switch field.Name {
13290 case "kind":
13291 return ec.fieldContext___Type_kind(ctx, field)
13292 case "name":
13293 return ec.fieldContext___Type_name(ctx, field)
13294 case "description":
13295 return ec.fieldContext___Type_description(ctx, field)
13296 case "fields":
13297 return ec.fieldContext___Type_fields(ctx, field)
13298 case "interfaces":
13299 return ec.fieldContext___Type_interfaces(ctx, field)
13300 case "possibleTypes":
13301 return ec.fieldContext___Type_possibleTypes(ctx, field)
13302 case "enumValues":
13303 return ec.fieldContext___Type_enumValues(ctx, field)
13304 case "inputFields":
13305 return ec.fieldContext___Type_inputFields(ctx, field)
13306 case "ofType":
13307 return ec.fieldContext___Type_ofType(ctx, field)
13308 case "specifiedByURL":
13309 return ec.fieldContext___Type_specifiedByURL(ctx, field)
13310 }
13311 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
13312 },
13313 }
13314 return fc, nil
13315}
13316
13317func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
13318 fc, err := ec.fieldContext___Field_isDeprecated(ctx, field)
13319 if err != nil {
13320 return graphql.Null
13321 }
13322 ctx = graphql.WithFieldContext(ctx, fc)
13323 defer func() {
13324 if r := recover(); r != nil {
13325 ec.Error(ctx, ec.Recover(ctx, r))
13326 ret = graphql.Null
13327 }
13328 }()
13329 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13330 ctx = rctx // use context from middleware stack in children
13331 return obj.IsDeprecated(), nil
13332 })
13333 if err != nil {
13334 ec.Error(ctx, err)
13335 return graphql.Null
13336 }
13337 if resTmp == nil {
13338 if !graphql.HasFieldError(ctx, fc) {
13339 ec.Errorf(ctx, "must not be null")
13340 }
13341 return graphql.Null
13342 }
13343 res := resTmp.(bool)
13344 fc.Result = res
13345 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
13346}
13347
13348func (ec *executionContext) fieldContext___Field_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13349 fc = &graphql.FieldContext{
13350 Object: "__Field",
13351 Field: field,
13352 IsMethod: true,
13353 IsResolver: false,
13354 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13355 return nil, errors.New("field of type Boolean does not have child fields")
13356 },
13357 }
13358 return fc, nil
13359}
13360
13361func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
13362 fc, err := ec.fieldContext___Field_deprecationReason(ctx, field)
13363 if err != nil {
13364 return graphql.Null
13365 }
13366 ctx = graphql.WithFieldContext(ctx, fc)
13367 defer func() {
13368 if r := recover(); r != nil {
13369 ec.Error(ctx, ec.Recover(ctx, r))
13370 ret = graphql.Null
13371 }
13372 }()
13373 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13374 ctx = rctx // use context from middleware stack in children
13375 return obj.DeprecationReason(), nil
13376 })
13377 if err != nil {
13378 ec.Error(ctx, err)
13379 return graphql.Null
13380 }
13381 if resTmp == nil {
13382 return graphql.Null
13383 }
13384 res := resTmp.(*string)
13385 fc.Result = res
13386 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
13387}
13388
13389func (ec *executionContext) fieldContext___Field_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13390 fc = &graphql.FieldContext{
13391 Object: "__Field",
13392 Field: field,
13393 IsMethod: true,
13394 IsResolver: false,
13395 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13396 return nil, errors.New("field of type String does not have child fields")
13397 },
13398 }
13399 return fc, nil
13400}
13401
13402func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
13403 fc, err := ec.fieldContext___InputValue_name(ctx, field)
13404 if err != nil {
13405 return graphql.Null
13406 }
13407 ctx = graphql.WithFieldContext(ctx, fc)
13408 defer func() {
13409 if r := recover(); r != nil {
13410 ec.Error(ctx, ec.Recover(ctx, r))
13411 ret = graphql.Null
13412 }
13413 }()
13414 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13415 ctx = rctx // use context from middleware stack in children
13416 return obj.Name, nil
13417 })
13418 if err != nil {
13419 ec.Error(ctx, err)
13420 return graphql.Null
13421 }
13422 if resTmp == nil {
13423 if !graphql.HasFieldError(ctx, fc) {
13424 ec.Errorf(ctx, "must not be null")
13425 }
13426 return graphql.Null
13427 }
13428 res := resTmp.(string)
13429 fc.Result = res
13430 return ec.marshalNString2string(ctx, field.Selections, res)
13431}
13432
13433func (ec *executionContext) fieldContext___InputValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13434 fc = &graphql.FieldContext{
13435 Object: "__InputValue",
13436 Field: field,
13437 IsMethod: false,
13438 IsResolver: false,
13439 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13440 return nil, errors.New("field of type String does not have child fields")
13441 },
13442 }
13443 return fc, nil
13444}
13445
13446func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
13447 fc, err := ec.fieldContext___InputValue_description(ctx, field)
13448 if err != nil {
13449 return graphql.Null
13450 }
13451 ctx = graphql.WithFieldContext(ctx, fc)
13452 defer func() {
13453 if r := recover(); r != nil {
13454 ec.Error(ctx, ec.Recover(ctx, r))
13455 ret = graphql.Null
13456 }
13457 }()
13458 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13459 ctx = rctx // use context from middleware stack in children
13460 return obj.Description(), nil
13461 })
13462 if err != nil {
13463 ec.Error(ctx, err)
13464 return graphql.Null
13465 }
13466 if resTmp == nil {
13467 return graphql.Null
13468 }
13469 res := resTmp.(*string)
13470 fc.Result = res
13471 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
13472}
13473
13474func (ec *executionContext) fieldContext___InputValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13475 fc = &graphql.FieldContext{
13476 Object: "__InputValue",
13477 Field: field,
13478 IsMethod: true,
13479 IsResolver: false,
13480 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13481 return nil, errors.New("field of type String does not have child fields")
13482 },
13483 }
13484 return fc, nil
13485}
13486
13487func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
13488 fc, err := ec.fieldContext___InputValue_type(ctx, field)
13489 if err != nil {
13490 return graphql.Null
13491 }
13492 ctx = graphql.WithFieldContext(ctx, fc)
13493 defer func() {
13494 if r := recover(); r != nil {
13495 ec.Error(ctx, ec.Recover(ctx, r))
13496 ret = graphql.Null
13497 }
13498 }()
13499 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13500 ctx = rctx // use context from middleware stack in children
13501 return obj.Type, nil
13502 })
13503 if err != nil {
13504 ec.Error(ctx, err)
13505 return graphql.Null
13506 }
13507 if resTmp == nil {
13508 if !graphql.HasFieldError(ctx, fc) {
13509 ec.Errorf(ctx, "must not be null")
13510 }
13511 return graphql.Null
13512 }
13513 res := resTmp.(*introspection.Type)
13514 fc.Result = res
13515 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
13516}
13517
13518func (ec *executionContext) fieldContext___InputValue_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13519 fc = &graphql.FieldContext{
13520 Object: "__InputValue",
13521 Field: field,
13522 IsMethod: false,
13523 IsResolver: false,
13524 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13525 switch field.Name {
13526 case "kind":
13527 return ec.fieldContext___Type_kind(ctx, field)
13528 case "name":
13529 return ec.fieldContext___Type_name(ctx, field)
13530 case "description":
13531 return ec.fieldContext___Type_description(ctx, field)
13532 case "fields":
13533 return ec.fieldContext___Type_fields(ctx, field)
13534 case "interfaces":
13535 return ec.fieldContext___Type_interfaces(ctx, field)
13536 case "possibleTypes":
13537 return ec.fieldContext___Type_possibleTypes(ctx, field)
13538 case "enumValues":
13539 return ec.fieldContext___Type_enumValues(ctx, field)
13540 case "inputFields":
13541 return ec.fieldContext___Type_inputFields(ctx, field)
13542 case "ofType":
13543 return ec.fieldContext___Type_ofType(ctx, field)
13544 case "specifiedByURL":
13545 return ec.fieldContext___Type_specifiedByURL(ctx, field)
13546 }
13547 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
13548 },
13549 }
13550 return fc, nil
13551}
13552
13553func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
13554 fc, err := ec.fieldContext___InputValue_defaultValue(ctx, field)
13555 if err != nil {
13556 return graphql.Null
13557 }
13558 ctx = graphql.WithFieldContext(ctx, fc)
13559 defer func() {
13560 if r := recover(); r != nil {
13561 ec.Error(ctx, ec.Recover(ctx, r))
13562 ret = graphql.Null
13563 }
13564 }()
13565 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13566 ctx = rctx // use context from middleware stack in children
13567 return obj.DefaultValue, nil
13568 })
13569 if err != nil {
13570 ec.Error(ctx, err)
13571 return graphql.Null
13572 }
13573 if resTmp == nil {
13574 return graphql.Null
13575 }
13576 res := resTmp.(*string)
13577 fc.Result = res
13578 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
13579}
13580
13581func (ec *executionContext) fieldContext___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13582 fc = &graphql.FieldContext{
13583 Object: "__InputValue",
13584 Field: field,
13585 IsMethod: false,
13586 IsResolver: false,
13587 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13588 return nil, errors.New("field of type String does not have child fields")
13589 },
13590 }
13591 return fc, nil
13592}
13593
13594func (ec *executionContext) ___Schema_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
13595 fc, err := ec.fieldContext___Schema_description(ctx, field)
13596 if err != nil {
13597 return graphql.Null
13598 }
13599 ctx = graphql.WithFieldContext(ctx, fc)
13600 defer func() {
13601 if r := recover(); r != nil {
13602 ec.Error(ctx, ec.Recover(ctx, r))
13603 ret = graphql.Null
13604 }
13605 }()
13606 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13607 ctx = rctx // use context from middleware stack in children
13608 return obj.Description(), nil
13609 })
13610 if err != nil {
13611 ec.Error(ctx, err)
13612 return graphql.Null
13613 }
13614 if resTmp == nil {
13615 return graphql.Null
13616 }
13617 res := resTmp.(*string)
13618 fc.Result = res
13619 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
13620}
13621
13622func (ec *executionContext) fieldContext___Schema_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13623 fc = &graphql.FieldContext{
13624 Object: "__Schema",
13625 Field: field,
13626 IsMethod: true,
13627 IsResolver: false,
13628 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13629 return nil, errors.New("field of type String does not have child fields")
13630 },
13631 }
13632 return fc, nil
13633}
13634
13635func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
13636 fc, err := ec.fieldContext___Schema_types(ctx, field)
13637 if err != nil {
13638 return graphql.Null
13639 }
13640 ctx = graphql.WithFieldContext(ctx, fc)
13641 defer func() {
13642 if r := recover(); r != nil {
13643 ec.Error(ctx, ec.Recover(ctx, r))
13644 ret = graphql.Null
13645 }
13646 }()
13647 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13648 ctx = rctx // use context from middleware stack in children
13649 return obj.Types(), nil
13650 })
13651 if err != nil {
13652 ec.Error(ctx, err)
13653 return graphql.Null
13654 }
13655 if resTmp == nil {
13656 if !graphql.HasFieldError(ctx, fc) {
13657 ec.Errorf(ctx, "must not be null")
13658 }
13659 return graphql.Null
13660 }
13661 res := resTmp.([]introspection.Type)
13662 fc.Result = res
13663 return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
13664}
13665
13666func (ec *executionContext) fieldContext___Schema_types(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13667 fc = &graphql.FieldContext{
13668 Object: "__Schema",
13669 Field: field,
13670 IsMethod: true,
13671 IsResolver: false,
13672 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13673 switch field.Name {
13674 case "kind":
13675 return ec.fieldContext___Type_kind(ctx, field)
13676 case "name":
13677 return ec.fieldContext___Type_name(ctx, field)
13678 case "description":
13679 return ec.fieldContext___Type_description(ctx, field)
13680 case "fields":
13681 return ec.fieldContext___Type_fields(ctx, field)
13682 case "interfaces":
13683 return ec.fieldContext___Type_interfaces(ctx, field)
13684 case "possibleTypes":
13685 return ec.fieldContext___Type_possibleTypes(ctx, field)
13686 case "enumValues":
13687 return ec.fieldContext___Type_enumValues(ctx, field)
13688 case "inputFields":
13689 return ec.fieldContext___Type_inputFields(ctx, field)
13690 case "ofType":
13691 return ec.fieldContext___Type_ofType(ctx, field)
13692 case "specifiedByURL":
13693 return ec.fieldContext___Type_specifiedByURL(ctx, field)
13694 }
13695 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
13696 },
13697 }
13698 return fc, nil
13699}
13700
13701func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
13702 fc, err := ec.fieldContext___Schema_queryType(ctx, field)
13703 if err != nil {
13704 return graphql.Null
13705 }
13706 ctx = graphql.WithFieldContext(ctx, fc)
13707 defer func() {
13708 if r := recover(); r != nil {
13709 ec.Error(ctx, ec.Recover(ctx, r))
13710 ret = graphql.Null
13711 }
13712 }()
13713 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13714 ctx = rctx // use context from middleware stack in children
13715 return obj.QueryType(), nil
13716 })
13717 if err != nil {
13718 ec.Error(ctx, err)
13719 return graphql.Null
13720 }
13721 if resTmp == nil {
13722 if !graphql.HasFieldError(ctx, fc) {
13723 ec.Errorf(ctx, "must not be null")
13724 }
13725 return graphql.Null
13726 }
13727 res := resTmp.(*introspection.Type)
13728 fc.Result = res
13729 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
13730}
13731
13732func (ec *executionContext) fieldContext___Schema_queryType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13733 fc = &graphql.FieldContext{
13734 Object: "__Schema",
13735 Field: field,
13736 IsMethod: true,
13737 IsResolver: false,
13738 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13739 switch field.Name {
13740 case "kind":
13741 return ec.fieldContext___Type_kind(ctx, field)
13742 case "name":
13743 return ec.fieldContext___Type_name(ctx, field)
13744 case "description":
13745 return ec.fieldContext___Type_description(ctx, field)
13746 case "fields":
13747 return ec.fieldContext___Type_fields(ctx, field)
13748 case "interfaces":
13749 return ec.fieldContext___Type_interfaces(ctx, field)
13750 case "possibleTypes":
13751 return ec.fieldContext___Type_possibleTypes(ctx, field)
13752 case "enumValues":
13753 return ec.fieldContext___Type_enumValues(ctx, field)
13754 case "inputFields":
13755 return ec.fieldContext___Type_inputFields(ctx, field)
13756 case "ofType":
13757 return ec.fieldContext___Type_ofType(ctx, field)
13758 case "specifiedByURL":
13759 return ec.fieldContext___Type_specifiedByURL(ctx, field)
13760 }
13761 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
13762 },
13763 }
13764 return fc, nil
13765}
13766
13767func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
13768 fc, err := ec.fieldContext___Schema_mutationType(ctx, field)
13769 if err != nil {
13770 return graphql.Null
13771 }
13772 ctx = graphql.WithFieldContext(ctx, fc)
13773 defer func() {
13774 if r := recover(); r != nil {
13775 ec.Error(ctx, ec.Recover(ctx, r))
13776 ret = graphql.Null
13777 }
13778 }()
13779 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13780 ctx = rctx // use context from middleware stack in children
13781 return obj.MutationType(), nil
13782 })
13783 if err != nil {
13784 ec.Error(ctx, err)
13785 return graphql.Null
13786 }
13787 if resTmp == nil {
13788 return graphql.Null
13789 }
13790 res := resTmp.(*introspection.Type)
13791 fc.Result = res
13792 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
13793}
13794
13795func (ec *executionContext) fieldContext___Schema_mutationType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13796 fc = &graphql.FieldContext{
13797 Object: "__Schema",
13798 Field: field,
13799 IsMethod: true,
13800 IsResolver: false,
13801 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13802 switch field.Name {
13803 case "kind":
13804 return ec.fieldContext___Type_kind(ctx, field)
13805 case "name":
13806 return ec.fieldContext___Type_name(ctx, field)
13807 case "description":
13808 return ec.fieldContext___Type_description(ctx, field)
13809 case "fields":
13810 return ec.fieldContext___Type_fields(ctx, field)
13811 case "interfaces":
13812 return ec.fieldContext___Type_interfaces(ctx, field)
13813 case "possibleTypes":
13814 return ec.fieldContext___Type_possibleTypes(ctx, field)
13815 case "enumValues":
13816 return ec.fieldContext___Type_enumValues(ctx, field)
13817 case "inputFields":
13818 return ec.fieldContext___Type_inputFields(ctx, field)
13819 case "ofType":
13820 return ec.fieldContext___Type_ofType(ctx, field)
13821 case "specifiedByURL":
13822 return ec.fieldContext___Type_specifiedByURL(ctx, field)
13823 }
13824 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
13825 },
13826 }
13827 return fc, nil
13828}
13829
13830func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
13831 fc, err := ec.fieldContext___Schema_subscriptionType(ctx, field)
13832 if err != nil {
13833 return graphql.Null
13834 }
13835 ctx = graphql.WithFieldContext(ctx, fc)
13836 defer func() {
13837 if r := recover(); r != nil {
13838 ec.Error(ctx, ec.Recover(ctx, r))
13839 ret = graphql.Null
13840 }
13841 }()
13842 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13843 ctx = rctx // use context from middleware stack in children
13844 return obj.SubscriptionType(), nil
13845 })
13846 if err != nil {
13847 ec.Error(ctx, err)
13848 return graphql.Null
13849 }
13850 if resTmp == nil {
13851 return graphql.Null
13852 }
13853 res := resTmp.(*introspection.Type)
13854 fc.Result = res
13855 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
13856}
13857
13858func (ec *executionContext) fieldContext___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13859 fc = &graphql.FieldContext{
13860 Object: "__Schema",
13861 Field: field,
13862 IsMethod: true,
13863 IsResolver: false,
13864 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13865 switch field.Name {
13866 case "kind":
13867 return ec.fieldContext___Type_kind(ctx, field)
13868 case "name":
13869 return ec.fieldContext___Type_name(ctx, field)
13870 case "description":
13871 return ec.fieldContext___Type_description(ctx, field)
13872 case "fields":
13873 return ec.fieldContext___Type_fields(ctx, field)
13874 case "interfaces":
13875 return ec.fieldContext___Type_interfaces(ctx, field)
13876 case "possibleTypes":
13877 return ec.fieldContext___Type_possibleTypes(ctx, field)
13878 case "enumValues":
13879 return ec.fieldContext___Type_enumValues(ctx, field)
13880 case "inputFields":
13881 return ec.fieldContext___Type_inputFields(ctx, field)
13882 case "ofType":
13883 return ec.fieldContext___Type_ofType(ctx, field)
13884 case "specifiedByURL":
13885 return ec.fieldContext___Type_specifiedByURL(ctx, field)
13886 }
13887 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
13888 },
13889 }
13890 return fc, nil
13891}
13892
13893func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
13894 fc, err := ec.fieldContext___Schema_directives(ctx, field)
13895 if err != nil {
13896 return graphql.Null
13897 }
13898 ctx = graphql.WithFieldContext(ctx, fc)
13899 defer func() {
13900 if r := recover(); r != nil {
13901 ec.Error(ctx, ec.Recover(ctx, r))
13902 ret = graphql.Null
13903 }
13904 }()
13905 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13906 ctx = rctx // use context from middleware stack in children
13907 return obj.Directives(), nil
13908 })
13909 if err != nil {
13910 ec.Error(ctx, err)
13911 return graphql.Null
13912 }
13913 if resTmp == nil {
13914 if !graphql.HasFieldError(ctx, fc) {
13915 ec.Errorf(ctx, "must not be null")
13916 }
13917 return graphql.Null
13918 }
13919 res := resTmp.([]introspection.Directive)
13920 fc.Result = res
13921 return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
13922}
13923
13924func (ec *executionContext) fieldContext___Schema_directives(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13925 fc = &graphql.FieldContext{
13926 Object: "__Schema",
13927 Field: field,
13928 IsMethod: true,
13929 IsResolver: false,
13930 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13931 switch field.Name {
13932 case "name":
13933 return ec.fieldContext___Directive_name(ctx, field)
13934 case "description":
13935 return ec.fieldContext___Directive_description(ctx, field)
13936 case "locations":
13937 return ec.fieldContext___Directive_locations(ctx, field)
13938 case "args":
13939 return ec.fieldContext___Directive_args(ctx, field)
13940 case "isRepeatable":
13941 return ec.fieldContext___Directive_isRepeatable(ctx, field)
13942 }
13943 return nil, fmt.Errorf("no field named %q was found under type __Directive", field.Name)
13944 },
13945 }
13946 return fc, nil
13947}
13948
13949func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
13950 fc, err := ec.fieldContext___Type_kind(ctx, field)
13951 if err != nil {
13952 return graphql.Null
13953 }
13954 ctx = graphql.WithFieldContext(ctx, fc)
13955 defer func() {
13956 if r := recover(); r != nil {
13957 ec.Error(ctx, ec.Recover(ctx, r))
13958 ret = graphql.Null
13959 }
13960 }()
13961 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
13962 ctx = rctx // use context from middleware stack in children
13963 return obj.Kind(), nil
13964 })
13965 if err != nil {
13966 ec.Error(ctx, err)
13967 return graphql.Null
13968 }
13969 if resTmp == nil {
13970 if !graphql.HasFieldError(ctx, fc) {
13971 ec.Errorf(ctx, "must not be null")
13972 }
13973 return graphql.Null
13974 }
13975 res := resTmp.(string)
13976 fc.Result = res
13977 return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
13978}
13979
13980func (ec *executionContext) fieldContext___Type_kind(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13981 fc = &graphql.FieldContext{
13982 Object: "__Type",
13983 Field: field,
13984 IsMethod: true,
13985 IsResolver: false,
13986 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13987 return nil, errors.New("field of type __TypeKind does not have child fields")
13988 },
13989 }
13990 return fc, nil
13991}
13992
13993func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
13994 fc, err := ec.fieldContext___Type_name(ctx, field)
13995 if err != nil {
13996 return graphql.Null
13997 }
13998 ctx = graphql.WithFieldContext(ctx, fc)
13999 defer func() {
14000 if r := recover(); r != nil {
14001 ec.Error(ctx, ec.Recover(ctx, r))
14002 ret = graphql.Null
14003 }
14004 }()
14005 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
14006 ctx = rctx // use context from middleware stack in children
14007 return obj.Name(), nil
14008 })
14009 if err != nil {
14010 ec.Error(ctx, err)
14011 return graphql.Null
14012 }
14013 if resTmp == nil {
14014 return graphql.Null
14015 }
14016 res := resTmp.(*string)
14017 fc.Result = res
14018 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
14019}
14020
14021func (ec *executionContext) fieldContext___Type_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14022 fc = &graphql.FieldContext{
14023 Object: "__Type",
14024 Field: field,
14025 IsMethod: true,
14026 IsResolver: false,
14027 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14028 return nil, errors.New("field of type String does not have child fields")
14029 },
14030 }
14031 return fc, nil
14032}
14033
14034func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14035 fc, err := ec.fieldContext___Type_description(ctx, field)
14036 if err != nil {
14037 return graphql.Null
14038 }
14039 ctx = graphql.WithFieldContext(ctx, fc)
14040 defer func() {
14041 if r := recover(); r != nil {
14042 ec.Error(ctx, ec.Recover(ctx, r))
14043 ret = graphql.Null
14044 }
14045 }()
14046 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
14047 ctx = rctx // use context from middleware stack in children
14048 return obj.Description(), nil
14049 })
14050 if err != nil {
14051 ec.Error(ctx, err)
14052 return graphql.Null
14053 }
14054 if resTmp == nil {
14055 return graphql.Null
14056 }
14057 res := resTmp.(*string)
14058 fc.Result = res
14059 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
14060}
14061
14062func (ec *executionContext) fieldContext___Type_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14063 fc = &graphql.FieldContext{
14064 Object: "__Type",
14065 Field: field,
14066 IsMethod: true,
14067 IsResolver: false,
14068 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14069 return nil, errors.New("field of type String does not have child fields")
14070 },
14071 }
14072 return fc, nil
14073}
14074
14075func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14076 fc, err := ec.fieldContext___Type_fields(ctx, field)
14077 if err != nil {
14078 return graphql.Null
14079 }
14080 ctx = graphql.WithFieldContext(ctx, fc)
14081 defer func() {
14082 if r := recover(); r != nil {
14083 ec.Error(ctx, ec.Recover(ctx, r))
14084 ret = graphql.Null
14085 }
14086 }()
14087 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
14088 ctx = rctx // use context from middleware stack in children
14089 return obj.Fields(fc.Args["includeDeprecated"].(bool)), nil
14090 })
14091 if err != nil {
14092 ec.Error(ctx, err)
14093 return graphql.Null
14094 }
14095 if resTmp == nil {
14096 return graphql.Null
14097 }
14098 res := resTmp.([]introspection.Field)
14099 fc.Result = res
14100 return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
14101}
14102
14103func (ec *executionContext) fieldContext___Type_fields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14104 fc = &graphql.FieldContext{
14105 Object: "__Type",
14106 Field: field,
14107 IsMethod: true,
14108 IsResolver: false,
14109 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14110 switch field.Name {
14111 case "name":
14112 return ec.fieldContext___Field_name(ctx, field)
14113 case "description":
14114 return ec.fieldContext___Field_description(ctx, field)
14115 case "args":
14116 return ec.fieldContext___Field_args(ctx, field)
14117 case "type":
14118 return ec.fieldContext___Field_type(ctx, field)
14119 case "isDeprecated":
14120 return ec.fieldContext___Field_isDeprecated(ctx, field)
14121 case "deprecationReason":
14122 return ec.fieldContext___Field_deprecationReason(ctx, field)
14123 }
14124 return nil, fmt.Errorf("no field named %q was found under type __Field", field.Name)
14125 },
14126 }
14127 defer func() {
14128 if r := recover(); r != nil {
14129 err = ec.Recover(ctx, r)
14130 ec.Error(ctx, err)
14131 }
14132 }()
14133 ctx = graphql.WithFieldContext(ctx, fc)
14134 if fc.Args, err = ec.field___Type_fields_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
14135 ec.Error(ctx, err)
14136 return
14137 }
14138 return fc, nil
14139}
14140
14141func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14142 fc, err := ec.fieldContext___Type_interfaces(ctx, field)
14143 if err != nil {
14144 return graphql.Null
14145 }
14146 ctx = graphql.WithFieldContext(ctx, fc)
14147 defer func() {
14148 if r := recover(); r != nil {
14149 ec.Error(ctx, ec.Recover(ctx, r))
14150 ret = graphql.Null
14151 }
14152 }()
14153 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
14154 ctx = rctx // use context from middleware stack in children
14155 return obj.Interfaces(), nil
14156 })
14157 if err != nil {
14158 ec.Error(ctx, err)
14159 return graphql.Null
14160 }
14161 if resTmp == nil {
14162 return graphql.Null
14163 }
14164 res := resTmp.([]introspection.Type)
14165 fc.Result = res
14166 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
14167}
14168
14169func (ec *executionContext) fieldContext___Type_interfaces(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14170 fc = &graphql.FieldContext{
14171 Object: "__Type",
14172 Field: field,
14173 IsMethod: true,
14174 IsResolver: false,
14175 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14176 switch field.Name {
14177 case "kind":
14178 return ec.fieldContext___Type_kind(ctx, field)
14179 case "name":
14180 return ec.fieldContext___Type_name(ctx, field)
14181 case "description":
14182 return ec.fieldContext___Type_description(ctx, field)
14183 case "fields":
14184 return ec.fieldContext___Type_fields(ctx, field)
14185 case "interfaces":
14186 return ec.fieldContext___Type_interfaces(ctx, field)
14187 case "possibleTypes":
14188 return ec.fieldContext___Type_possibleTypes(ctx, field)
14189 case "enumValues":
14190 return ec.fieldContext___Type_enumValues(ctx, field)
14191 case "inputFields":
14192 return ec.fieldContext___Type_inputFields(ctx, field)
14193 case "ofType":
14194 return ec.fieldContext___Type_ofType(ctx, field)
14195 case "specifiedByURL":
14196 return ec.fieldContext___Type_specifiedByURL(ctx, field)
14197 }
14198 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
14199 },
14200 }
14201 return fc, nil
14202}
14203
14204func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14205 fc, err := ec.fieldContext___Type_possibleTypes(ctx, field)
14206 if err != nil {
14207 return graphql.Null
14208 }
14209 ctx = graphql.WithFieldContext(ctx, fc)
14210 defer func() {
14211 if r := recover(); r != nil {
14212 ec.Error(ctx, ec.Recover(ctx, r))
14213 ret = graphql.Null
14214 }
14215 }()
14216 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
14217 ctx = rctx // use context from middleware stack in children
14218 return obj.PossibleTypes(), nil
14219 })
14220 if err != nil {
14221 ec.Error(ctx, err)
14222 return graphql.Null
14223 }
14224 if resTmp == nil {
14225 return graphql.Null
14226 }
14227 res := resTmp.([]introspection.Type)
14228 fc.Result = res
14229 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
14230}
14231
14232func (ec *executionContext) fieldContext___Type_possibleTypes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14233 fc = &graphql.FieldContext{
14234 Object: "__Type",
14235 Field: field,
14236 IsMethod: true,
14237 IsResolver: false,
14238 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14239 switch field.Name {
14240 case "kind":
14241 return ec.fieldContext___Type_kind(ctx, field)
14242 case "name":
14243 return ec.fieldContext___Type_name(ctx, field)
14244 case "description":
14245 return ec.fieldContext___Type_description(ctx, field)
14246 case "fields":
14247 return ec.fieldContext___Type_fields(ctx, field)
14248 case "interfaces":
14249 return ec.fieldContext___Type_interfaces(ctx, field)
14250 case "possibleTypes":
14251 return ec.fieldContext___Type_possibleTypes(ctx, field)
14252 case "enumValues":
14253 return ec.fieldContext___Type_enumValues(ctx, field)
14254 case "inputFields":
14255 return ec.fieldContext___Type_inputFields(ctx, field)
14256 case "ofType":
14257 return ec.fieldContext___Type_ofType(ctx, field)
14258 case "specifiedByURL":
14259 return ec.fieldContext___Type_specifiedByURL(ctx, field)
14260 }
14261 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
14262 },
14263 }
14264 return fc, nil
14265}
14266
14267func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14268 fc, err := ec.fieldContext___Type_enumValues(ctx, field)
14269 if err != nil {
14270 return graphql.Null
14271 }
14272 ctx = graphql.WithFieldContext(ctx, fc)
14273 defer func() {
14274 if r := recover(); r != nil {
14275 ec.Error(ctx, ec.Recover(ctx, r))
14276 ret = graphql.Null
14277 }
14278 }()
14279 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
14280 ctx = rctx // use context from middleware stack in children
14281 return obj.EnumValues(fc.Args["includeDeprecated"].(bool)), nil
14282 })
14283 if err != nil {
14284 ec.Error(ctx, err)
14285 return graphql.Null
14286 }
14287 if resTmp == nil {
14288 return graphql.Null
14289 }
14290 res := resTmp.([]introspection.EnumValue)
14291 fc.Result = res
14292 return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
14293}
14294
14295func (ec *executionContext) fieldContext___Type_enumValues(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14296 fc = &graphql.FieldContext{
14297 Object: "__Type",
14298 Field: field,
14299 IsMethod: true,
14300 IsResolver: false,
14301 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14302 switch field.Name {
14303 case "name":
14304 return ec.fieldContext___EnumValue_name(ctx, field)
14305 case "description":
14306 return ec.fieldContext___EnumValue_description(ctx, field)
14307 case "isDeprecated":
14308 return ec.fieldContext___EnumValue_isDeprecated(ctx, field)
14309 case "deprecationReason":
14310 return ec.fieldContext___EnumValue_deprecationReason(ctx, field)
14311 }
14312 return nil, fmt.Errorf("no field named %q was found under type __EnumValue", field.Name)
14313 },
14314 }
14315 defer func() {
14316 if r := recover(); r != nil {
14317 err = ec.Recover(ctx, r)
14318 ec.Error(ctx, err)
14319 }
14320 }()
14321 ctx = graphql.WithFieldContext(ctx, fc)
14322 if fc.Args, err = ec.field___Type_enumValues_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
14323 ec.Error(ctx, err)
14324 return
14325 }
14326 return fc, nil
14327}
14328
14329func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14330 fc, err := ec.fieldContext___Type_inputFields(ctx, field)
14331 if err != nil {
14332 return graphql.Null
14333 }
14334 ctx = graphql.WithFieldContext(ctx, fc)
14335 defer func() {
14336 if r := recover(); r != nil {
14337 ec.Error(ctx, ec.Recover(ctx, r))
14338 ret = graphql.Null
14339 }
14340 }()
14341 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
14342 ctx = rctx // use context from middleware stack in children
14343 return obj.InputFields(), nil
14344 })
14345 if err != nil {
14346 ec.Error(ctx, err)
14347 return graphql.Null
14348 }
14349 if resTmp == nil {
14350 return graphql.Null
14351 }
14352 res := resTmp.([]introspection.InputValue)
14353 fc.Result = res
14354 return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
14355}
14356
14357func (ec *executionContext) fieldContext___Type_inputFields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14358 fc = &graphql.FieldContext{
14359 Object: "__Type",
14360 Field: field,
14361 IsMethod: true,
14362 IsResolver: false,
14363 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14364 switch field.Name {
14365 case "name":
14366 return ec.fieldContext___InputValue_name(ctx, field)
14367 case "description":
14368 return ec.fieldContext___InputValue_description(ctx, field)
14369 case "type":
14370 return ec.fieldContext___InputValue_type(ctx, field)
14371 case "defaultValue":
14372 return ec.fieldContext___InputValue_defaultValue(ctx, field)
14373 }
14374 return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
14375 },
14376 }
14377 return fc, nil
14378}
14379
14380func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14381 fc, err := ec.fieldContext___Type_ofType(ctx, field)
14382 if err != nil {
14383 return graphql.Null
14384 }
14385 ctx = graphql.WithFieldContext(ctx, fc)
14386 defer func() {
14387 if r := recover(); r != nil {
14388 ec.Error(ctx, ec.Recover(ctx, r))
14389 ret = graphql.Null
14390 }
14391 }()
14392 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
14393 ctx = rctx // use context from middleware stack in children
14394 return obj.OfType(), nil
14395 })
14396 if err != nil {
14397 ec.Error(ctx, err)
14398 return graphql.Null
14399 }
14400 if resTmp == nil {
14401 return graphql.Null
14402 }
14403 res := resTmp.(*introspection.Type)
14404 fc.Result = res
14405 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
14406}
14407
14408func (ec *executionContext) fieldContext___Type_ofType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14409 fc = &graphql.FieldContext{
14410 Object: "__Type",
14411 Field: field,
14412 IsMethod: true,
14413 IsResolver: false,
14414 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14415 switch field.Name {
14416 case "kind":
14417 return ec.fieldContext___Type_kind(ctx, field)
14418 case "name":
14419 return ec.fieldContext___Type_name(ctx, field)
14420 case "description":
14421 return ec.fieldContext___Type_description(ctx, field)
14422 case "fields":
14423 return ec.fieldContext___Type_fields(ctx, field)
14424 case "interfaces":
14425 return ec.fieldContext___Type_interfaces(ctx, field)
14426 case "possibleTypes":
14427 return ec.fieldContext___Type_possibleTypes(ctx, field)
14428 case "enumValues":
14429 return ec.fieldContext___Type_enumValues(ctx, field)
14430 case "inputFields":
14431 return ec.fieldContext___Type_inputFields(ctx, field)
14432 case "ofType":
14433 return ec.fieldContext___Type_ofType(ctx, field)
14434 case "specifiedByURL":
14435 return ec.fieldContext___Type_specifiedByURL(ctx, field)
14436 }
14437 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
14438 },
14439 }
14440 return fc, nil
14441}
14442
14443func (ec *executionContext) ___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14444 fc, err := ec.fieldContext___Type_specifiedByURL(ctx, field)
14445 if err != nil {
14446 return graphql.Null
14447 }
14448 ctx = graphql.WithFieldContext(ctx, fc)
14449 defer func() {
14450 if r := recover(); r != nil {
14451 ec.Error(ctx, ec.Recover(ctx, r))
14452 ret = graphql.Null
14453 }
14454 }()
14455 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
14456 ctx = rctx // use context from middleware stack in children
14457 return obj.SpecifiedByURL(), nil
14458 })
14459 if err != nil {
14460 ec.Error(ctx, err)
14461 return graphql.Null
14462 }
14463 if resTmp == nil {
14464 return graphql.Null
14465 }
14466 res := resTmp.(*string)
14467 fc.Result = res
14468 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
14469}
14470
14471func (ec *executionContext) fieldContext___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14472 fc = &graphql.FieldContext{
14473 Object: "__Type",
14474 Field: field,
14475 IsMethod: true,
14476 IsResolver: false,
14477 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14478 return nil, errors.New("field of type String does not have child fields")
14479 },
14480 }
14481 return fc, nil
14482}
14483
14484// endregion **************************** field.gotpl *****************************
14485
14486// region **************************** input.gotpl *****************************
14487
14488func (ec *executionContext) unmarshalInputAddCommentAndCloseBugInput(ctx context.Context, obj interface{}) (models.AddCommentAndCloseBugInput, error) {
14489 var it models.AddCommentAndCloseBugInput
14490 asMap := map[string]interface{}{}
14491 for k, v := range obj.(map[string]interface{}) {
14492 asMap[k] = v
14493 }
14494
14495 fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "message", "files"}
14496 for _, k := range fieldsInOrder {
14497 v, ok := asMap[k]
14498 if !ok {
14499 continue
14500 }
14501 switch k {
14502 case "clientMutationId":
14503 var err error
14504
14505 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
14506 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
14507 if err != nil {
14508 return it, err
14509 }
14510 case "repoRef":
14511 var err error
14512
14513 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
14514 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
14515 if err != nil {
14516 return it, err
14517 }
14518 case "prefix":
14519 var err error
14520
14521 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
14522 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
14523 if err != nil {
14524 return it, err
14525 }
14526 case "message":
14527 var err error
14528
14529 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
14530 it.Message, err = ec.unmarshalNString2string(ctx, v)
14531 if err != nil {
14532 return it, err
14533 }
14534 case "files":
14535 var err error
14536
14537 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
14538 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
14539 if err != nil {
14540 return it, err
14541 }
14542 }
14543 }
14544
14545 return it, nil
14546}
14547
14548func (ec *executionContext) unmarshalInputAddCommentAndReopenBugInput(ctx context.Context, obj interface{}) (models.AddCommentAndReopenBugInput, error) {
14549 var it models.AddCommentAndReopenBugInput
14550 asMap := map[string]interface{}{}
14551 for k, v := range obj.(map[string]interface{}) {
14552 asMap[k] = v
14553 }
14554
14555 fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "message", "files"}
14556 for _, k := range fieldsInOrder {
14557 v, ok := asMap[k]
14558 if !ok {
14559 continue
14560 }
14561 switch k {
14562 case "clientMutationId":
14563 var err error
14564
14565 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
14566 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
14567 if err != nil {
14568 return it, err
14569 }
14570 case "repoRef":
14571 var err error
14572
14573 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
14574 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
14575 if err != nil {
14576 return it, err
14577 }
14578 case "prefix":
14579 var err error
14580
14581 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
14582 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
14583 if err != nil {
14584 return it, err
14585 }
14586 case "message":
14587 var err error
14588
14589 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
14590 it.Message, err = ec.unmarshalNString2string(ctx, v)
14591 if err != nil {
14592 return it, err
14593 }
14594 case "files":
14595 var err error
14596
14597 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
14598 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
14599 if err != nil {
14600 return it, err
14601 }
14602 }
14603 }
14604
14605 return it, nil
14606}
14607
14608func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
14609 var it models.AddCommentInput
14610 asMap := map[string]interface{}{}
14611 for k, v := range obj.(map[string]interface{}) {
14612 asMap[k] = v
14613 }
14614
14615 fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "message", "files"}
14616 for _, k := range fieldsInOrder {
14617 v, ok := asMap[k]
14618 if !ok {
14619 continue
14620 }
14621 switch k {
14622 case "clientMutationId":
14623 var err error
14624
14625 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
14626 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
14627 if err != nil {
14628 return it, err
14629 }
14630 case "repoRef":
14631 var err error
14632
14633 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
14634 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
14635 if err != nil {
14636 return it, err
14637 }
14638 case "prefix":
14639 var err error
14640
14641 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
14642 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
14643 if err != nil {
14644 return it, err
14645 }
14646 case "message":
14647 var err error
14648
14649 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
14650 it.Message, err = ec.unmarshalNString2string(ctx, v)
14651 if err != nil {
14652 return it, err
14653 }
14654 case "files":
14655 var err error
14656
14657 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
14658 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
14659 if err != nil {
14660 return it, err
14661 }
14662 }
14663 }
14664
14665 return it, nil
14666}
14667
14668func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
14669 var it models.ChangeLabelInput
14670 asMap := map[string]interface{}{}
14671 for k, v := range obj.(map[string]interface{}) {
14672 asMap[k] = v
14673 }
14674
14675 fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "added", "Removed"}
14676 for _, k := range fieldsInOrder {
14677 v, ok := asMap[k]
14678 if !ok {
14679 continue
14680 }
14681 switch k {
14682 case "clientMutationId":
14683 var err error
14684
14685 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
14686 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
14687 if err != nil {
14688 return it, err
14689 }
14690 case "repoRef":
14691 var err error
14692
14693 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
14694 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
14695 if err != nil {
14696 return it, err
14697 }
14698 case "prefix":
14699 var err error
14700
14701 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
14702 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
14703 if err != nil {
14704 return it, err
14705 }
14706 case "added":
14707 var err error
14708
14709 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("added"))
14710 it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
14711 if err != nil {
14712 return it, err
14713 }
14714 case "Removed":
14715 var err error
14716
14717 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Removed"))
14718 it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
14719 if err != nil {
14720 return it, err
14721 }
14722 }
14723 }
14724
14725 return it, nil
14726}
14727
14728func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
14729 var it models.CloseBugInput
14730 asMap := map[string]interface{}{}
14731 for k, v := range obj.(map[string]interface{}) {
14732 asMap[k] = v
14733 }
14734
14735 fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix"}
14736 for _, k := range fieldsInOrder {
14737 v, ok := asMap[k]
14738 if !ok {
14739 continue
14740 }
14741 switch k {
14742 case "clientMutationId":
14743 var err error
14744
14745 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
14746 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
14747 if err != nil {
14748 return it, err
14749 }
14750 case "repoRef":
14751 var err error
14752
14753 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
14754 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
14755 if err != nil {
14756 return it, err
14757 }
14758 case "prefix":
14759 var err error
14760
14761 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
14762 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
14763 if err != nil {
14764 return it, err
14765 }
14766 }
14767 }
14768
14769 return it, nil
14770}
14771
14772func (ec *executionContext) unmarshalInputEditCommentInput(ctx context.Context, obj interface{}) (models.EditCommentInput, error) {
14773 var it models.EditCommentInput
14774 asMap := map[string]interface{}{}
14775 for k, v := range obj.(map[string]interface{}) {
14776 asMap[k] = v
14777 }
14778
14779 fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "target", "message", "files"}
14780 for _, k := range fieldsInOrder {
14781 v, ok := asMap[k]
14782 if !ok {
14783 continue
14784 }
14785 switch k {
14786 case "clientMutationId":
14787 var err error
14788
14789 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
14790 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
14791 if err != nil {
14792 return it, err
14793 }
14794 case "repoRef":
14795 var err error
14796
14797 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
14798 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
14799 if err != nil {
14800 return it, err
14801 }
14802 case "prefix":
14803 var err error
14804
14805 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
14806 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
14807 if err != nil {
14808 return it, err
14809 }
14810 case "target":
14811 var err error
14812
14813 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("target"))
14814 it.Target, err = ec.unmarshalNString2string(ctx, v)
14815 if err != nil {
14816 return it, err
14817 }
14818 case "message":
14819 var err error
14820
14821 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
14822 it.Message, err = ec.unmarshalNString2string(ctx, v)
14823 if err != nil {
14824 return it, err
14825 }
14826 case "files":
14827 var err error
14828
14829 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
14830 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
14831 if err != nil {
14832 return it, err
14833 }
14834 }
14835 }
14836
14837 return it, nil
14838}
14839
14840func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
14841 var it models.NewBugInput
14842 asMap := map[string]interface{}{}
14843 for k, v := range obj.(map[string]interface{}) {
14844 asMap[k] = v
14845 }
14846
14847 fieldsInOrder := [...]string{"clientMutationId", "repoRef", "title", "message", "files"}
14848 for _, k := range fieldsInOrder {
14849 v, ok := asMap[k]
14850 if !ok {
14851 continue
14852 }
14853 switch k {
14854 case "clientMutationId":
14855 var err error
14856
14857 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
14858 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
14859 if err != nil {
14860 return it, err
14861 }
14862 case "repoRef":
14863 var err error
14864
14865 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
14866 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
14867 if err != nil {
14868 return it, err
14869 }
14870 case "title":
14871 var err error
14872
14873 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
14874 it.Title, err = ec.unmarshalNString2string(ctx, v)
14875 if err != nil {
14876 return it, err
14877 }
14878 case "message":
14879 var err error
14880
14881 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
14882 it.Message, err = ec.unmarshalNString2string(ctx, v)
14883 if err != nil {
14884 return it, err
14885 }
14886 case "files":
14887 var err error
14888
14889 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
14890 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
14891 if err != nil {
14892 return it, err
14893 }
14894 }
14895 }
14896
14897 return it, nil
14898}
14899
14900func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
14901 var it models.OpenBugInput
14902 asMap := map[string]interface{}{}
14903 for k, v := range obj.(map[string]interface{}) {
14904 asMap[k] = v
14905 }
14906
14907 fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix"}
14908 for _, k := range fieldsInOrder {
14909 v, ok := asMap[k]
14910 if !ok {
14911 continue
14912 }
14913 switch k {
14914 case "clientMutationId":
14915 var err error
14916
14917 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
14918 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
14919 if err != nil {
14920 return it, err
14921 }
14922 case "repoRef":
14923 var err error
14924
14925 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
14926 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
14927 if err != nil {
14928 return it, err
14929 }
14930 case "prefix":
14931 var err error
14932
14933 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
14934 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
14935 if err != nil {
14936 return it, err
14937 }
14938 }
14939 }
14940
14941 return it, nil
14942}
14943
14944func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
14945 var it models.SetTitleInput
14946 asMap := map[string]interface{}{}
14947 for k, v := range obj.(map[string]interface{}) {
14948 asMap[k] = v
14949 }
14950
14951 fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "title"}
14952 for _, k := range fieldsInOrder {
14953 v, ok := asMap[k]
14954 if !ok {
14955 continue
14956 }
14957 switch k {
14958 case "clientMutationId":
14959 var err error
14960
14961 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
14962 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
14963 if err != nil {
14964 return it, err
14965 }
14966 case "repoRef":
14967 var err error
14968
14969 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
14970 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
14971 if err != nil {
14972 return it, err
14973 }
14974 case "prefix":
14975 var err error
14976
14977 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
14978 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
14979 if err != nil {
14980 return it, err
14981 }
14982 case "title":
14983 var err error
14984
14985 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
14986 it.Title, err = ec.unmarshalNString2string(ctx, v)
14987 if err != nil {
14988 return it, err
14989 }
14990 }
14991 }
14992
14993 return it, nil
14994}
14995
14996// endregion **************************** input.gotpl *****************************
14997
14998// region ************************** interface.gotpl ***************************
14999
15000func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj models.Authored) graphql.Marshaler {
15001 switch obj := (obj).(type) {
15002 case nil:
15003 return graphql.Null
15004 case bug.Comment:
15005 return ec._Comment(ctx, sel, &obj)
15006 case *bug.Comment:
15007 if obj == nil {
15008 return graphql.Null
15009 }
15010 return ec._Comment(ctx, sel, obj)
15011 case models.BugWrapper:
15012 if obj == nil {
15013 return graphql.Null
15014 }
15015 return ec._Bug(ctx, sel, obj)
15016 case *bug.CreateOperation:
15017 if obj == nil {
15018 return graphql.Null
15019 }
15020 return ec._CreateOperation(ctx, sel, obj)
15021 case *bug.SetTitleOperation:
15022 if obj == nil {
15023 return graphql.Null
15024 }
15025 return ec._SetTitleOperation(ctx, sel, obj)
15026 case *bug.AddCommentOperation:
15027 if obj == nil {
15028 return graphql.Null
15029 }
15030 return ec._AddCommentOperation(ctx, sel, obj)
15031 case *bug.EditCommentOperation:
15032 if obj == nil {
15033 return graphql.Null
15034 }
15035 return ec._EditCommentOperation(ctx, sel, obj)
15036 case *bug.SetStatusOperation:
15037 if obj == nil {
15038 return graphql.Null
15039 }
15040 return ec._SetStatusOperation(ctx, sel, obj)
15041 case *bug.LabelChangeOperation:
15042 if obj == nil {
15043 return graphql.Null
15044 }
15045 return ec._LabelChangeOperation(ctx, sel, obj)
15046 case *bug.CreateTimelineItem:
15047 if obj == nil {
15048 return graphql.Null
15049 }
15050 return ec._CreateTimelineItem(ctx, sel, obj)
15051 case *bug.AddCommentTimelineItem:
15052 if obj == nil {
15053 return graphql.Null
15054 }
15055 return ec._AddCommentTimelineItem(ctx, sel, obj)
15056 case *bug.LabelChangeTimelineItem:
15057 if obj == nil {
15058 return graphql.Null
15059 }
15060 return ec._LabelChangeTimelineItem(ctx, sel, obj)
15061 case *bug.SetStatusTimelineItem:
15062 if obj == nil {
15063 return graphql.Null
15064 }
15065 return ec._SetStatusTimelineItem(ctx, sel, obj)
15066 case *bug.SetTitleTimelineItem:
15067 if obj == nil {
15068 return graphql.Null
15069 }
15070 return ec._SetTitleTimelineItem(ctx, sel, obj)
15071 default:
15072 panic(fmt.Errorf("unexpected type %T", obj))
15073 }
15074}
15075
15076func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj dag.Operation) graphql.Marshaler {
15077 switch obj := (obj).(type) {
15078 case nil:
15079 return graphql.Null
15080 case *bug.CreateOperation:
15081 if obj == nil {
15082 return graphql.Null
15083 }
15084 return ec._CreateOperation(ctx, sel, obj)
15085 case *bug.SetTitleOperation:
15086 if obj == nil {
15087 return graphql.Null
15088 }
15089 return ec._SetTitleOperation(ctx, sel, obj)
15090 case *bug.AddCommentOperation:
15091 if obj == nil {
15092 return graphql.Null
15093 }
15094 return ec._AddCommentOperation(ctx, sel, obj)
15095 case *bug.EditCommentOperation:
15096 if obj == nil {
15097 return graphql.Null
15098 }
15099 return ec._EditCommentOperation(ctx, sel, obj)
15100 case *bug.SetStatusOperation:
15101 if obj == nil {
15102 return graphql.Null
15103 }
15104 return ec._SetStatusOperation(ctx, sel, obj)
15105 case *bug.LabelChangeOperation:
15106 if obj == nil {
15107 return graphql.Null
15108 }
15109 return ec._LabelChangeOperation(ctx, sel, obj)
15110 default:
15111 panic(fmt.Errorf("unexpected type %T", obj))
15112 }
15113}
15114
15115func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
15116 switch obj := (obj).(type) {
15117 case nil:
15118 return graphql.Null
15119 case *bug.CreateTimelineItem:
15120 if obj == nil {
15121 return graphql.Null
15122 }
15123 return ec._CreateTimelineItem(ctx, sel, obj)
15124 case *bug.AddCommentTimelineItem:
15125 if obj == nil {
15126 return graphql.Null
15127 }
15128 return ec._AddCommentTimelineItem(ctx, sel, obj)
15129 case bug.LabelChangeTimelineItem:
15130 return ec._LabelChangeTimelineItem(ctx, sel, &obj)
15131 case *bug.LabelChangeTimelineItem:
15132 if obj == nil {
15133 return graphql.Null
15134 }
15135 return ec._LabelChangeTimelineItem(ctx, sel, obj)
15136 case bug.SetStatusTimelineItem:
15137 return ec._SetStatusTimelineItem(ctx, sel, &obj)
15138 case *bug.SetStatusTimelineItem:
15139 if obj == nil {
15140 return graphql.Null
15141 }
15142 return ec._SetStatusTimelineItem(ctx, sel, obj)
15143 case bug.SetTitleTimelineItem:
15144 return ec._SetTitleTimelineItem(ctx, sel, &obj)
15145 case *bug.SetTitleTimelineItem:
15146 if obj == nil {
15147 return graphql.Null
15148 }
15149 return ec._SetTitleTimelineItem(ctx, sel, obj)
15150 default:
15151 panic(fmt.Errorf("unexpected type %T", obj))
15152 }
15153}
15154
15155// endregion ************************** interface.gotpl ***************************
15156
15157// region **************************** object.gotpl ****************************
15158
15159var addCommentAndCloseBugPayloadImplementors = []string{"AddCommentAndCloseBugPayload"}
15160
15161func (ec *executionContext) _AddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentAndCloseBugPayload) graphql.Marshaler {
15162 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentAndCloseBugPayloadImplementors)
15163 out := graphql.NewFieldSet(fields)
15164 var invalids uint32
15165 for i, field := range fields {
15166 switch field.Name {
15167 case "__typename":
15168 out.Values[i] = graphql.MarshalString("AddCommentAndCloseBugPayload")
15169 case "clientMutationId":
15170
15171 out.Values[i] = ec._AddCommentAndCloseBugPayload_clientMutationId(ctx, field, obj)
15172
15173 case "bug":
15174
15175 out.Values[i] = ec._AddCommentAndCloseBugPayload_bug(ctx, field, obj)
15176
15177 if out.Values[i] == graphql.Null {
15178 invalids++
15179 }
15180 case "commentOperation":
15181
15182 out.Values[i] = ec._AddCommentAndCloseBugPayload_commentOperation(ctx, field, obj)
15183
15184 if out.Values[i] == graphql.Null {
15185 invalids++
15186 }
15187 case "statusOperation":
15188
15189 out.Values[i] = ec._AddCommentAndCloseBugPayload_statusOperation(ctx, field, obj)
15190
15191 if out.Values[i] == graphql.Null {
15192 invalids++
15193 }
15194 default:
15195 panic("unknown field " + strconv.Quote(field.Name))
15196 }
15197 }
15198 out.Dispatch()
15199 if invalids > 0 {
15200 return graphql.Null
15201 }
15202 return out
15203}
15204
15205var addCommentAndReopenBugPayloadImplementors = []string{"AddCommentAndReopenBugPayload"}
15206
15207func (ec *executionContext) _AddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentAndReopenBugPayload) graphql.Marshaler {
15208 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentAndReopenBugPayloadImplementors)
15209 out := graphql.NewFieldSet(fields)
15210 var invalids uint32
15211 for i, field := range fields {
15212 switch field.Name {
15213 case "__typename":
15214 out.Values[i] = graphql.MarshalString("AddCommentAndReopenBugPayload")
15215 case "clientMutationId":
15216
15217 out.Values[i] = ec._AddCommentAndReopenBugPayload_clientMutationId(ctx, field, obj)
15218
15219 case "bug":
15220
15221 out.Values[i] = ec._AddCommentAndReopenBugPayload_bug(ctx, field, obj)
15222
15223 if out.Values[i] == graphql.Null {
15224 invalids++
15225 }
15226 case "commentOperation":
15227
15228 out.Values[i] = ec._AddCommentAndReopenBugPayload_commentOperation(ctx, field, obj)
15229
15230 if out.Values[i] == graphql.Null {
15231 invalids++
15232 }
15233 case "statusOperation":
15234
15235 out.Values[i] = ec._AddCommentAndReopenBugPayload_statusOperation(ctx, field, obj)
15236
15237 if out.Values[i] == graphql.Null {
15238 invalids++
15239 }
15240 default:
15241 panic("unknown field " + strconv.Quote(field.Name))
15242 }
15243 }
15244 out.Dispatch()
15245 if invalids > 0 {
15246 return graphql.Null
15247 }
15248 return out
15249}
15250
15251var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
15252
15253func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
15254 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
15255 out := graphql.NewFieldSet(fields)
15256 var invalids uint32
15257 for i, field := range fields {
15258 switch field.Name {
15259 case "__typename":
15260 out.Values[i] = graphql.MarshalString("AddCommentOperation")
15261 case "id":
15262 field := field
15263
15264 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15265 defer func() {
15266 if r := recover(); r != nil {
15267 ec.Error(ctx, ec.Recover(ctx, r))
15268 }
15269 }()
15270 res = ec._AddCommentOperation_id(ctx, field, obj)
15271 if res == graphql.Null {
15272 atomic.AddUint32(&invalids, 1)
15273 }
15274 return res
15275 }
15276
15277 out.Concurrently(i, func() graphql.Marshaler {
15278 return innerFunc(ctx)
15279
15280 })
15281 case "author":
15282 field := field
15283
15284 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15285 defer func() {
15286 if r := recover(); r != nil {
15287 ec.Error(ctx, ec.Recover(ctx, r))
15288 }
15289 }()
15290 res = ec._AddCommentOperation_author(ctx, field, obj)
15291 if res == graphql.Null {
15292 atomic.AddUint32(&invalids, 1)
15293 }
15294 return res
15295 }
15296
15297 out.Concurrently(i, func() graphql.Marshaler {
15298 return innerFunc(ctx)
15299
15300 })
15301 case "date":
15302 field := field
15303
15304 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15305 defer func() {
15306 if r := recover(); r != nil {
15307 ec.Error(ctx, ec.Recover(ctx, r))
15308 }
15309 }()
15310 res = ec._AddCommentOperation_date(ctx, field, obj)
15311 if res == graphql.Null {
15312 atomic.AddUint32(&invalids, 1)
15313 }
15314 return res
15315 }
15316
15317 out.Concurrently(i, func() graphql.Marshaler {
15318 return innerFunc(ctx)
15319
15320 })
15321 case "message":
15322
15323 out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
15324
15325 if out.Values[i] == graphql.Null {
15326 atomic.AddUint32(&invalids, 1)
15327 }
15328 case "files":
15329
15330 out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
15331
15332 if out.Values[i] == graphql.Null {
15333 atomic.AddUint32(&invalids, 1)
15334 }
15335 default:
15336 panic("unknown field " + strconv.Quote(field.Name))
15337 }
15338 }
15339 out.Dispatch()
15340 if invalids > 0 {
15341 return graphql.Null
15342 }
15343 return out
15344}
15345
15346var addCommentPayloadImplementors = []string{"AddCommentPayload"}
15347
15348func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
15349 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
15350 out := graphql.NewFieldSet(fields)
15351 var invalids uint32
15352 for i, field := range fields {
15353 switch field.Name {
15354 case "__typename":
15355 out.Values[i] = graphql.MarshalString("AddCommentPayload")
15356 case "clientMutationId":
15357
15358 out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
15359
15360 case "bug":
15361
15362 out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
15363
15364 if out.Values[i] == graphql.Null {
15365 invalids++
15366 }
15367 case "operation":
15368
15369 out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
15370
15371 if out.Values[i] == graphql.Null {
15372 invalids++
15373 }
15374 default:
15375 panic("unknown field " + strconv.Quote(field.Name))
15376 }
15377 }
15378 out.Dispatch()
15379 if invalids > 0 {
15380 return graphql.Null
15381 }
15382 return out
15383}
15384
15385var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
15386
15387func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
15388 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
15389 out := graphql.NewFieldSet(fields)
15390 var invalids uint32
15391 for i, field := range fields {
15392 switch field.Name {
15393 case "__typename":
15394 out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
15395 case "id":
15396 field := field
15397
15398 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15399 defer func() {
15400 if r := recover(); r != nil {
15401 ec.Error(ctx, ec.Recover(ctx, r))
15402 }
15403 }()
15404 res = ec._AddCommentTimelineItem_id(ctx, field, obj)
15405 if res == graphql.Null {
15406 atomic.AddUint32(&invalids, 1)
15407 }
15408 return res
15409 }
15410
15411 out.Concurrently(i, func() graphql.Marshaler {
15412 return innerFunc(ctx)
15413
15414 })
15415 case "author":
15416 field := field
15417
15418 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15419 defer func() {
15420 if r := recover(); r != nil {
15421 ec.Error(ctx, ec.Recover(ctx, r))
15422 }
15423 }()
15424 res = ec._AddCommentTimelineItem_author(ctx, field, obj)
15425 if res == graphql.Null {
15426 atomic.AddUint32(&invalids, 1)
15427 }
15428 return res
15429 }
15430
15431 out.Concurrently(i, func() graphql.Marshaler {
15432 return innerFunc(ctx)
15433
15434 })
15435 case "message":
15436
15437 out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
15438
15439 if out.Values[i] == graphql.Null {
15440 atomic.AddUint32(&invalids, 1)
15441 }
15442 case "messageIsEmpty":
15443
15444 out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
15445
15446 if out.Values[i] == graphql.Null {
15447 atomic.AddUint32(&invalids, 1)
15448 }
15449 case "files":
15450
15451 out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
15452
15453 if out.Values[i] == graphql.Null {
15454 atomic.AddUint32(&invalids, 1)
15455 }
15456 case "createdAt":
15457 field := field
15458
15459 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15460 defer func() {
15461 if r := recover(); r != nil {
15462 ec.Error(ctx, ec.Recover(ctx, r))
15463 }
15464 }()
15465 res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
15466 if res == graphql.Null {
15467 atomic.AddUint32(&invalids, 1)
15468 }
15469 return res
15470 }
15471
15472 out.Concurrently(i, func() graphql.Marshaler {
15473 return innerFunc(ctx)
15474
15475 })
15476 case "lastEdit":
15477 field := field
15478
15479 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15480 defer func() {
15481 if r := recover(); r != nil {
15482 ec.Error(ctx, ec.Recover(ctx, r))
15483 }
15484 }()
15485 res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
15486 if res == graphql.Null {
15487 atomic.AddUint32(&invalids, 1)
15488 }
15489 return res
15490 }
15491
15492 out.Concurrently(i, func() graphql.Marshaler {
15493 return innerFunc(ctx)
15494
15495 })
15496 case "edited":
15497
15498 out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
15499
15500 if out.Values[i] == graphql.Null {
15501 atomic.AddUint32(&invalids, 1)
15502 }
15503 case "history":
15504
15505 out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
15506
15507 if out.Values[i] == graphql.Null {
15508 atomic.AddUint32(&invalids, 1)
15509 }
15510 default:
15511 panic("unknown field " + strconv.Quote(field.Name))
15512 }
15513 }
15514 out.Dispatch()
15515 if invalids > 0 {
15516 return graphql.Null
15517 }
15518 return out
15519}
15520
15521var bugImplementors = []string{"Bug", "Authored"}
15522
15523func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
15524 fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
15525 out := graphql.NewFieldSet(fields)
15526 var invalids uint32
15527 for i, field := range fields {
15528 switch field.Name {
15529 case "__typename":
15530 out.Values[i] = graphql.MarshalString("Bug")
15531 case "id":
15532 field := field
15533
15534 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15535 defer func() {
15536 if r := recover(); r != nil {
15537 ec.Error(ctx, ec.Recover(ctx, r))
15538 }
15539 }()
15540 res = ec._Bug_id(ctx, field, obj)
15541 if res == graphql.Null {
15542 atomic.AddUint32(&invalids, 1)
15543 }
15544 return res
15545 }
15546
15547 out.Concurrently(i, func() graphql.Marshaler {
15548 return innerFunc(ctx)
15549
15550 })
15551 case "humanId":
15552 field := field
15553
15554 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15555 defer func() {
15556 if r := recover(); r != nil {
15557 ec.Error(ctx, ec.Recover(ctx, r))
15558 }
15559 }()
15560 res = ec._Bug_humanId(ctx, field, obj)
15561 if res == graphql.Null {
15562 atomic.AddUint32(&invalids, 1)
15563 }
15564 return res
15565 }
15566
15567 out.Concurrently(i, func() graphql.Marshaler {
15568 return innerFunc(ctx)
15569
15570 })
15571 case "status":
15572 field := field
15573
15574 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15575 defer func() {
15576 if r := recover(); r != nil {
15577 ec.Error(ctx, ec.Recover(ctx, r))
15578 }
15579 }()
15580 res = ec._Bug_status(ctx, field, obj)
15581 if res == graphql.Null {
15582 atomic.AddUint32(&invalids, 1)
15583 }
15584 return res
15585 }
15586
15587 out.Concurrently(i, func() graphql.Marshaler {
15588 return innerFunc(ctx)
15589
15590 })
15591 case "title":
15592
15593 out.Values[i] = ec._Bug_title(ctx, field, obj)
15594
15595 if out.Values[i] == graphql.Null {
15596 atomic.AddUint32(&invalids, 1)
15597 }
15598 case "labels":
15599
15600 out.Values[i] = ec._Bug_labels(ctx, field, obj)
15601
15602 if out.Values[i] == graphql.Null {
15603 atomic.AddUint32(&invalids, 1)
15604 }
15605 case "author":
15606
15607 out.Values[i] = ec._Bug_author(ctx, field, obj)
15608
15609 if out.Values[i] == graphql.Null {
15610 atomic.AddUint32(&invalids, 1)
15611 }
15612 case "createdAt":
15613
15614 out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
15615
15616 if out.Values[i] == graphql.Null {
15617 atomic.AddUint32(&invalids, 1)
15618 }
15619 case "lastEdit":
15620
15621 out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
15622
15623 if out.Values[i] == graphql.Null {
15624 atomic.AddUint32(&invalids, 1)
15625 }
15626 case "actors":
15627 field := field
15628
15629 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15630 defer func() {
15631 if r := recover(); r != nil {
15632 ec.Error(ctx, ec.Recover(ctx, r))
15633 }
15634 }()
15635 res = ec._Bug_actors(ctx, field, obj)
15636 if res == graphql.Null {
15637 atomic.AddUint32(&invalids, 1)
15638 }
15639 return res
15640 }
15641
15642 out.Concurrently(i, func() graphql.Marshaler {
15643 return innerFunc(ctx)
15644
15645 })
15646 case "participants":
15647 field := field
15648
15649 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15650 defer func() {
15651 if r := recover(); r != nil {
15652 ec.Error(ctx, ec.Recover(ctx, r))
15653 }
15654 }()
15655 res = ec._Bug_participants(ctx, field, obj)
15656 if res == graphql.Null {
15657 atomic.AddUint32(&invalids, 1)
15658 }
15659 return res
15660 }
15661
15662 out.Concurrently(i, func() graphql.Marshaler {
15663 return innerFunc(ctx)
15664
15665 })
15666 case "comments":
15667 field := field
15668
15669 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15670 defer func() {
15671 if r := recover(); r != nil {
15672 ec.Error(ctx, ec.Recover(ctx, r))
15673 }
15674 }()
15675 res = ec._Bug_comments(ctx, field, obj)
15676 if res == graphql.Null {
15677 atomic.AddUint32(&invalids, 1)
15678 }
15679 return res
15680 }
15681
15682 out.Concurrently(i, func() graphql.Marshaler {
15683 return innerFunc(ctx)
15684
15685 })
15686 case "timeline":
15687 field := field
15688
15689 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15690 defer func() {
15691 if r := recover(); r != nil {
15692 ec.Error(ctx, ec.Recover(ctx, r))
15693 }
15694 }()
15695 res = ec._Bug_timeline(ctx, field, obj)
15696 if res == graphql.Null {
15697 atomic.AddUint32(&invalids, 1)
15698 }
15699 return res
15700 }
15701
15702 out.Concurrently(i, func() graphql.Marshaler {
15703 return innerFunc(ctx)
15704
15705 })
15706 case "operations":
15707 field := field
15708
15709 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15710 defer func() {
15711 if r := recover(); r != nil {
15712 ec.Error(ctx, ec.Recover(ctx, r))
15713 }
15714 }()
15715 res = ec._Bug_operations(ctx, field, obj)
15716 if res == graphql.Null {
15717 atomic.AddUint32(&invalids, 1)
15718 }
15719 return res
15720 }
15721
15722 out.Concurrently(i, func() graphql.Marshaler {
15723 return innerFunc(ctx)
15724
15725 })
15726 default:
15727 panic("unknown field " + strconv.Quote(field.Name))
15728 }
15729 }
15730 out.Dispatch()
15731 if invalids > 0 {
15732 return graphql.Null
15733 }
15734 return out
15735}
15736
15737var bugConnectionImplementors = []string{"BugConnection"}
15738
15739func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
15740 fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
15741 out := graphql.NewFieldSet(fields)
15742 var invalids uint32
15743 for i, field := range fields {
15744 switch field.Name {
15745 case "__typename":
15746 out.Values[i] = graphql.MarshalString("BugConnection")
15747 case "edges":
15748
15749 out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
15750
15751 if out.Values[i] == graphql.Null {
15752 invalids++
15753 }
15754 case "nodes":
15755
15756 out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
15757
15758 if out.Values[i] == graphql.Null {
15759 invalids++
15760 }
15761 case "pageInfo":
15762
15763 out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
15764
15765 if out.Values[i] == graphql.Null {
15766 invalids++
15767 }
15768 case "totalCount":
15769
15770 out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
15771
15772 if out.Values[i] == graphql.Null {
15773 invalids++
15774 }
15775 default:
15776 panic("unknown field " + strconv.Quote(field.Name))
15777 }
15778 }
15779 out.Dispatch()
15780 if invalids > 0 {
15781 return graphql.Null
15782 }
15783 return out
15784}
15785
15786var bugEdgeImplementors = []string{"BugEdge"}
15787
15788func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
15789 fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
15790 out := graphql.NewFieldSet(fields)
15791 var invalids uint32
15792 for i, field := range fields {
15793 switch field.Name {
15794 case "__typename":
15795 out.Values[i] = graphql.MarshalString("BugEdge")
15796 case "cursor":
15797
15798 out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
15799
15800 if out.Values[i] == graphql.Null {
15801 invalids++
15802 }
15803 case "node":
15804
15805 out.Values[i] = ec._BugEdge_node(ctx, field, obj)
15806
15807 if out.Values[i] == graphql.Null {
15808 invalids++
15809 }
15810 default:
15811 panic("unknown field " + strconv.Quote(field.Name))
15812 }
15813 }
15814 out.Dispatch()
15815 if invalids > 0 {
15816 return graphql.Null
15817 }
15818 return out
15819}
15820
15821var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
15822
15823func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
15824 fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
15825 out := graphql.NewFieldSet(fields)
15826 var invalids uint32
15827 for i, field := range fields {
15828 switch field.Name {
15829 case "__typename":
15830 out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
15831 case "clientMutationId":
15832
15833 out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
15834
15835 case "bug":
15836
15837 out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
15838
15839 if out.Values[i] == graphql.Null {
15840 invalids++
15841 }
15842 case "operation":
15843
15844 out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
15845
15846 if out.Values[i] == graphql.Null {
15847 invalids++
15848 }
15849 case "results":
15850
15851 out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
15852
15853 if out.Values[i] == graphql.Null {
15854 invalids++
15855 }
15856 default:
15857 panic("unknown field " + strconv.Quote(field.Name))
15858 }
15859 }
15860 out.Dispatch()
15861 if invalids > 0 {
15862 return graphql.Null
15863 }
15864 return out
15865}
15866
15867var closeBugPayloadImplementors = []string{"CloseBugPayload"}
15868
15869func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
15870 fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
15871 out := graphql.NewFieldSet(fields)
15872 var invalids uint32
15873 for i, field := range fields {
15874 switch field.Name {
15875 case "__typename":
15876 out.Values[i] = graphql.MarshalString("CloseBugPayload")
15877 case "clientMutationId":
15878
15879 out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
15880
15881 case "bug":
15882
15883 out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
15884
15885 if out.Values[i] == graphql.Null {
15886 invalids++
15887 }
15888 case "operation":
15889
15890 out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
15891
15892 if out.Values[i] == graphql.Null {
15893 invalids++
15894 }
15895 default:
15896 panic("unknown field " + strconv.Quote(field.Name))
15897 }
15898 }
15899 out.Dispatch()
15900 if invalids > 0 {
15901 return graphql.Null
15902 }
15903 return out
15904}
15905
15906var colorImplementors = []string{"Color"}
15907
15908func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
15909 fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
15910 out := graphql.NewFieldSet(fields)
15911 var invalids uint32
15912 for i, field := range fields {
15913 switch field.Name {
15914 case "__typename":
15915 out.Values[i] = graphql.MarshalString("Color")
15916 case "R":
15917 field := field
15918
15919 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15920 defer func() {
15921 if r := recover(); r != nil {
15922 ec.Error(ctx, ec.Recover(ctx, r))
15923 }
15924 }()
15925 res = ec._Color_R(ctx, field, obj)
15926 if res == graphql.Null {
15927 atomic.AddUint32(&invalids, 1)
15928 }
15929 return res
15930 }
15931
15932 out.Concurrently(i, func() graphql.Marshaler {
15933 return innerFunc(ctx)
15934
15935 })
15936 case "G":
15937 field := field
15938
15939 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15940 defer func() {
15941 if r := recover(); r != nil {
15942 ec.Error(ctx, ec.Recover(ctx, r))
15943 }
15944 }()
15945 res = ec._Color_G(ctx, field, obj)
15946 if res == graphql.Null {
15947 atomic.AddUint32(&invalids, 1)
15948 }
15949 return res
15950 }
15951
15952 out.Concurrently(i, func() graphql.Marshaler {
15953 return innerFunc(ctx)
15954
15955 })
15956 case "B":
15957 field := field
15958
15959 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15960 defer func() {
15961 if r := recover(); r != nil {
15962 ec.Error(ctx, ec.Recover(ctx, r))
15963 }
15964 }()
15965 res = ec._Color_B(ctx, field, obj)
15966 if res == graphql.Null {
15967 atomic.AddUint32(&invalids, 1)
15968 }
15969 return res
15970 }
15971
15972 out.Concurrently(i, func() graphql.Marshaler {
15973 return innerFunc(ctx)
15974
15975 })
15976 default:
15977 panic("unknown field " + strconv.Quote(field.Name))
15978 }
15979 }
15980 out.Dispatch()
15981 if invalids > 0 {
15982 return graphql.Null
15983 }
15984 return out
15985}
15986
15987var commentImplementors = []string{"Comment", "Authored"}
15988
15989func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
15990 fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
15991 out := graphql.NewFieldSet(fields)
15992 var invalids uint32
15993 for i, field := range fields {
15994 switch field.Name {
15995 case "__typename":
15996 out.Values[i] = graphql.MarshalString("Comment")
15997 case "author":
15998 field := field
15999
16000 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16001 defer func() {
16002 if r := recover(); r != nil {
16003 ec.Error(ctx, ec.Recover(ctx, r))
16004 }
16005 }()
16006 res = ec._Comment_author(ctx, field, obj)
16007 if res == graphql.Null {
16008 atomic.AddUint32(&invalids, 1)
16009 }
16010 return res
16011 }
16012
16013 out.Concurrently(i, func() graphql.Marshaler {
16014 return innerFunc(ctx)
16015
16016 })
16017 case "message":
16018
16019 out.Values[i] = ec._Comment_message(ctx, field, obj)
16020
16021 if out.Values[i] == graphql.Null {
16022 atomic.AddUint32(&invalids, 1)
16023 }
16024 case "files":
16025
16026 out.Values[i] = ec._Comment_files(ctx, field, obj)
16027
16028 if out.Values[i] == graphql.Null {
16029 atomic.AddUint32(&invalids, 1)
16030 }
16031 default:
16032 panic("unknown field " + strconv.Quote(field.Name))
16033 }
16034 }
16035 out.Dispatch()
16036 if invalids > 0 {
16037 return graphql.Null
16038 }
16039 return out
16040}
16041
16042var commentConnectionImplementors = []string{"CommentConnection"}
16043
16044func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
16045 fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
16046 out := graphql.NewFieldSet(fields)
16047 var invalids uint32
16048 for i, field := range fields {
16049 switch field.Name {
16050 case "__typename":
16051 out.Values[i] = graphql.MarshalString("CommentConnection")
16052 case "edges":
16053
16054 out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
16055
16056 if out.Values[i] == graphql.Null {
16057 invalids++
16058 }
16059 case "nodes":
16060
16061 out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
16062
16063 if out.Values[i] == graphql.Null {
16064 invalids++
16065 }
16066 case "pageInfo":
16067
16068 out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
16069
16070 if out.Values[i] == graphql.Null {
16071 invalids++
16072 }
16073 case "totalCount":
16074
16075 out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
16076
16077 if out.Values[i] == graphql.Null {
16078 invalids++
16079 }
16080 default:
16081 panic("unknown field " + strconv.Quote(field.Name))
16082 }
16083 }
16084 out.Dispatch()
16085 if invalids > 0 {
16086 return graphql.Null
16087 }
16088 return out
16089}
16090
16091var commentEdgeImplementors = []string{"CommentEdge"}
16092
16093func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
16094 fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
16095 out := graphql.NewFieldSet(fields)
16096 var invalids uint32
16097 for i, field := range fields {
16098 switch field.Name {
16099 case "__typename":
16100 out.Values[i] = graphql.MarshalString("CommentEdge")
16101 case "cursor":
16102
16103 out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
16104
16105 if out.Values[i] == graphql.Null {
16106 invalids++
16107 }
16108 case "node":
16109
16110 out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
16111
16112 if out.Values[i] == graphql.Null {
16113 invalids++
16114 }
16115 default:
16116 panic("unknown field " + strconv.Quote(field.Name))
16117 }
16118 }
16119 out.Dispatch()
16120 if invalids > 0 {
16121 return graphql.Null
16122 }
16123 return out
16124}
16125
16126var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
16127
16128func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
16129 fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
16130 out := graphql.NewFieldSet(fields)
16131 var invalids uint32
16132 for i, field := range fields {
16133 switch field.Name {
16134 case "__typename":
16135 out.Values[i] = graphql.MarshalString("CommentHistoryStep")
16136 case "message":
16137
16138 out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
16139
16140 if out.Values[i] == graphql.Null {
16141 atomic.AddUint32(&invalids, 1)
16142 }
16143 case "date":
16144 field := field
16145
16146 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16147 defer func() {
16148 if r := recover(); r != nil {
16149 ec.Error(ctx, ec.Recover(ctx, r))
16150 }
16151 }()
16152 res = ec._CommentHistoryStep_date(ctx, field, obj)
16153 if res == graphql.Null {
16154 atomic.AddUint32(&invalids, 1)
16155 }
16156 return res
16157 }
16158
16159 out.Concurrently(i, func() graphql.Marshaler {
16160 return innerFunc(ctx)
16161
16162 })
16163 default:
16164 panic("unknown field " + strconv.Quote(field.Name))
16165 }
16166 }
16167 out.Dispatch()
16168 if invalids > 0 {
16169 return graphql.Null
16170 }
16171 return out
16172}
16173
16174var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
16175
16176func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
16177 fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
16178 out := graphql.NewFieldSet(fields)
16179 var invalids uint32
16180 for i, field := range fields {
16181 switch field.Name {
16182 case "__typename":
16183 out.Values[i] = graphql.MarshalString("CreateOperation")
16184 case "id":
16185 field := field
16186
16187 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16188 defer func() {
16189 if r := recover(); r != nil {
16190 ec.Error(ctx, ec.Recover(ctx, r))
16191 }
16192 }()
16193 res = ec._CreateOperation_id(ctx, field, obj)
16194 if res == graphql.Null {
16195 atomic.AddUint32(&invalids, 1)
16196 }
16197 return res
16198 }
16199
16200 out.Concurrently(i, func() graphql.Marshaler {
16201 return innerFunc(ctx)
16202
16203 })
16204 case "author":
16205 field := field
16206
16207 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16208 defer func() {
16209 if r := recover(); r != nil {
16210 ec.Error(ctx, ec.Recover(ctx, r))
16211 }
16212 }()
16213 res = ec._CreateOperation_author(ctx, field, obj)
16214 if res == graphql.Null {
16215 atomic.AddUint32(&invalids, 1)
16216 }
16217 return res
16218 }
16219
16220 out.Concurrently(i, func() graphql.Marshaler {
16221 return innerFunc(ctx)
16222
16223 })
16224 case "date":
16225 field := field
16226
16227 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16228 defer func() {
16229 if r := recover(); r != nil {
16230 ec.Error(ctx, ec.Recover(ctx, r))
16231 }
16232 }()
16233 res = ec._CreateOperation_date(ctx, field, obj)
16234 if res == graphql.Null {
16235 atomic.AddUint32(&invalids, 1)
16236 }
16237 return res
16238 }
16239
16240 out.Concurrently(i, func() graphql.Marshaler {
16241 return innerFunc(ctx)
16242
16243 })
16244 case "title":
16245
16246 out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
16247
16248 if out.Values[i] == graphql.Null {
16249 atomic.AddUint32(&invalids, 1)
16250 }
16251 case "message":
16252
16253 out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
16254
16255 if out.Values[i] == graphql.Null {
16256 atomic.AddUint32(&invalids, 1)
16257 }
16258 case "files":
16259
16260 out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
16261
16262 if out.Values[i] == graphql.Null {
16263 atomic.AddUint32(&invalids, 1)
16264 }
16265 default:
16266 panic("unknown field " + strconv.Quote(field.Name))
16267 }
16268 }
16269 out.Dispatch()
16270 if invalids > 0 {
16271 return graphql.Null
16272 }
16273 return out
16274}
16275
16276var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
16277
16278func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
16279 fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
16280 out := graphql.NewFieldSet(fields)
16281 var invalids uint32
16282 for i, field := range fields {
16283 switch field.Name {
16284 case "__typename":
16285 out.Values[i] = graphql.MarshalString("CreateTimelineItem")
16286 case "id":
16287 field := field
16288
16289 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16290 defer func() {
16291 if r := recover(); r != nil {
16292 ec.Error(ctx, ec.Recover(ctx, r))
16293 }
16294 }()
16295 res = ec._CreateTimelineItem_id(ctx, field, obj)
16296 if res == graphql.Null {
16297 atomic.AddUint32(&invalids, 1)
16298 }
16299 return res
16300 }
16301
16302 out.Concurrently(i, func() graphql.Marshaler {
16303 return innerFunc(ctx)
16304
16305 })
16306 case "author":
16307 field := field
16308
16309 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16310 defer func() {
16311 if r := recover(); r != nil {
16312 ec.Error(ctx, ec.Recover(ctx, r))
16313 }
16314 }()
16315 res = ec._CreateTimelineItem_author(ctx, field, obj)
16316 if res == graphql.Null {
16317 atomic.AddUint32(&invalids, 1)
16318 }
16319 return res
16320 }
16321
16322 out.Concurrently(i, func() graphql.Marshaler {
16323 return innerFunc(ctx)
16324
16325 })
16326 case "message":
16327
16328 out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
16329
16330 if out.Values[i] == graphql.Null {
16331 atomic.AddUint32(&invalids, 1)
16332 }
16333 case "messageIsEmpty":
16334
16335 out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
16336
16337 if out.Values[i] == graphql.Null {
16338 atomic.AddUint32(&invalids, 1)
16339 }
16340 case "files":
16341
16342 out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
16343
16344 if out.Values[i] == graphql.Null {
16345 atomic.AddUint32(&invalids, 1)
16346 }
16347 case "createdAt":
16348 field := field
16349
16350 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16351 defer func() {
16352 if r := recover(); r != nil {
16353 ec.Error(ctx, ec.Recover(ctx, r))
16354 }
16355 }()
16356 res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
16357 if res == graphql.Null {
16358 atomic.AddUint32(&invalids, 1)
16359 }
16360 return res
16361 }
16362
16363 out.Concurrently(i, func() graphql.Marshaler {
16364 return innerFunc(ctx)
16365
16366 })
16367 case "lastEdit":
16368 field := field
16369
16370 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16371 defer func() {
16372 if r := recover(); r != nil {
16373 ec.Error(ctx, ec.Recover(ctx, r))
16374 }
16375 }()
16376 res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
16377 if res == graphql.Null {
16378 atomic.AddUint32(&invalids, 1)
16379 }
16380 return res
16381 }
16382
16383 out.Concurrently(i, func() graphql.Marshaler {
16384 return innerFunc(ctx)
16385
16386 })
16387 case "edited":
16388
16389 out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
16390
16391 if out.Values[i] == graphql.Null {
16392 atomic.AddUint32(&invalids, 1)
16393 }
16394 case "history":
16395
16396 out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
16397
16398 if out.Values[i] == graphql.Null {
16399 atomic.AddUint32(&invalids, 1)
16400 }
16401 default:
16402 panic("unknown field " + strconv.Quote(field.Name))
16403 }
16404 }
16405 out.Dispatch()
16406 if invalids > 0 {
16407 return graphql.Null
16408 }
16409 return out
16410}
16411
16412var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
16413
16414func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
16415 fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
16416 out := graphql.NewFieldSet(fields)
16417 var invalids uint32
16418 for i, field := range fields {
16419 switch field.Name {
16420 case "__typename":
16421 out.Values[i] = graphql.MarshalString("EditCommentOperation")
16422 case "id":
16423 field := field
16424
16425 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16426 defer func() {
16427 if r := recover(); r != nil {
16428 ec.Error(ctx, ec.Recover(ctx, r))
16429 }
16430 }()
16431 res = ec._EditCommentOperation_id(ctx, field, obj)
16432 if res == graphql.Null {
16433 atomic.AddUint32(&invalids, 1)
16434 }
16435 return res
16436 }
16437
16438 out.Concurrently(i, func() graphql.Marshaler {
16439 return innerFunc(ctx)
16440
16441 })
16442 case "author":
16443 field := field
16444
16445 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16446 defer func() {
16447 if r := recover(); r != nil {
16448 ec.Error(ctx, ec.Recover(ctx, r))
16449 }
16450 }()
16451 res = ec._EditCommentOperation_author(ctx, field, obj)
16452 if res == graphql.Null {
16453 atomic.AddUint32(&invalids, 1)
16454 }
16455 return res
16456 }
16457
16458 out.Concurrently(i, func() graphql.Marshaler {
16459 return innerFunc(ctx)
16460
16461 })
16462 case "date":
16463 field := field
16464
16465 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16466 defer func() {
16467 if r := recover(); r != nil {
16468 ec.Error(ctx, ec.Recover(ctx, r))
16469 }
16470 }()
16471 res = ec._EditCommentOperation_date(ctx, field, obj)
16472 if res == graphql.Null {
16473 atomic.AddUint32(&invalids, 1)
16474 }
16475 return res
16476 }
16477
16478 out.Concurrently(i, func() graphql.Marshaler {
16479 return innerFunc(ctx)
16480
16481 })
16482 case "target":
16483 field := field
16484
16485 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16486 defer func() {
16487 if r := recover(); r != nil {
16488 ec.Error(ctx, ec.Recover(ctx, r))
16489 }
16490 }()
16491 res = ec._EditCommentOperation_target(ctx, field, obj)
16492 if res == graphql.Null {
16493 atomic.AddUint32(&invalids, 1)
16494 }
16495 return res
16496 }
16497
16498 out.Concurrently(i, func() graphql.Marshaler {
16499 return innerFunc(ctx)
16500
16501 })
16502 case "message":
16503
16504 out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
16505
16506 if out.Values[i] == graphql.Null {
16507 atomic.AddUint32(&invalids, 1)
16508 }
16509 case "files":
16510
16511 out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
16512
16513 if out.Values[i] == graphql.Null {
16514 atomic.AddUint32(&invalids, 1)
16515 }
16516 default:
16517 panic("unknown field " + strconv.Quote(field.Name))
16518 }
16519 }
16520 out.Dispatch()
16521 if invalids > 0 {
16522 return graphql.Null
16523 }
16524 return out
16525}
16526
16527var editCommentPayloadImplementors = []string{"EditCommentPayload"}
16528
16529func (ec *executionContext) _EditCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.EditCommentPayload) graphql.Marshaler {
16530 fields := graphql.CollectFields(ec.OperationContext, sel, editCommentPayloadImplementors)
16531 out := graphql.NewFieldSet(fields)
16532 var invalids uint32
16533 for i, field := range fields {
16534 switch field.Name {
16535 case "__typename":
16536 out.Values[i] = graphql.MarshalString("EditCommentPayload")
16537 case "clientMutationId":
16538
16539 out.Values[i] = ec._EditCommentPayload_clientMutationId(ctx, field, obj)
16540
16541 case "bug":
16542
16543 out.Values[i] = ec._EditCommentPayload_bug(ctx, field, obj)
16544
16545 if out.Values[i] == graphql.Null {
16546 invalids++
16547 }
16548 case "operation":
16549
16550 out.Values[i] = ec._EditCommentPayload_operation(ctx, field, obj)
16551
16552 if out.Values[i] == graphql.Null {
16553 invalids++
16554 }
16555 default:
16556 panic("unknown field " + strconv.Quote(field.Name))
16557 }
16558 }
16559 out.Dispatch()
16560 if invalids > 0 {
16561 return graphql.Null
16562 }
16563 return out
16564}
16565
16566var identityImplementors = []string{"Identity"}
16567
16568func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj models.IdentityWrapper) graphql.Marshaler {
16569 fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
16570 out := graphql.NewFieldSet(fields)
16571 var invalids uint32
16572 for i, field := range fields {
16573 switch field.Name {
16574 case "__typename":
16575 out.Values[i] = graphql.MarshalString("Identity")
16576 case "id":
16577 field := field
16578
16579 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16580 defer func() {
16581 if r := recover(); r != nil {
16582 ec.Error(ctx, ec.Recover(ctx, r))
16583 }
16584 }()
16585 res = ec._Identity_id(ctx, field, obj)
16586 if res == graphql.Null {
16587 atomic.AddUint32(&invalids, 1)
16588 }
16589 return res
16590 }
16591
16592 out.Concurrently(i, func() graphql.Marshaler {
16593 return innerFunc(ctx)
16594
16595 })
16596 case "humanId":
16597 field := field
16598
16599 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16600 defer func() {
16601 if r := recover(); r != nil {
16602 ec.Error(ctx, ec.Recover(ctx, r))
16603 }
16604 }()
16605 res = ec._Identity_humanId(ctx, field, obj)
16606 if res == graphql.Null {
16607 atomic.AddUint32(&invalids, 1)
16608 }
16609 return res
16610 }
16611
16612 out.Concurrently(i, func() graphql.Marshaler {
16613 return innerFunc(ctx)
16614
16615 })
16616 case "name":
16617
16618 out.Values[i] = ec._Identity_name(ctx, field, obj)
16619
16620 case "email":
16621
16622 out.Values[i] = ec._Identity_email(ctx, field, obj)
16623
16624 case "login":
16625
16626 out.Values[i] = ec._Identity_login(ctx, field, obj)
16627
16628 case "displayName":
16629
16630 out.Values[i] = ec._Identity_displayName(ctx, field, obj)
16631
16632 if out.Values[i] == graphql.Null {
16633 atomic.AddUint32(&invalids, 1)
16634 }
16635 case "avatarUrl":
16636
16637 out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
16638
16639 case "isProtected":
16640
16641 out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
16642
16643 if out.Values[i] == graphql.Null {
16644 atomic.AddUint32(&invalids, 1)
16645 }
16646 default:
16647 panic("unknown field " + strconv.Quote(field.Name))
16648 }
16649 }
16650 out.Dispatch()
16651 if invalids > 0 {
16652 return graphql.Null
16653 }
16654 return out
16655}
16656
16657var identityConnectionImplementors = []string{"IdentityConnection"}
16658
16659func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
16660 fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
16661 out := graphql.NewFieldSet(fields)
16662 var invalids uint32
16663 for i, field := range fields {
16664 switch field.Name {
16665 case "__typename":
16666 out.Values[i] = graphql.MarshalString("IdentityConnection")
16667 case "edges":
16668
16669 out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
16670
16671 if out.Values[i] == graphql.Null {
16672 invalids++
16673 }
16674 case "nodes":
16675
16676 out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
16677
16678 if out.Values[i] == graphql.Null {
16679 invalids++
16680 }
16681 case "pageInfo":
16682
16683 out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
16684
16685 if out.Values[i] == graphql.Null {
16686 invalids++
16687 }
16688 case "totalCount":
16689
16690 out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
16691
16692 if out.Values[i] == graphql.Null {
16693 invalids++
16694 }
16695 default:
16696 panic("unknown field " + strconv.Quote(field.Name))
16697 }
16698 }
16699 out.Dispatch()
16700 if invalids > 0 {
16701 return graphql.Null
16702 }
16703 return out
16704}
16705
16706var identityEdgeImplementors = []string{"IdentityEdge"}
16707
16708func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
16709 fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
16710 out := graphql.NewFieldSet(fields)
16711 var invalids uint32
16712 for i, field := range fields {
16713 switch field.Name {
16714 case "__typename":
16715 out.Values[i] = graphql.MarshalString("IdentityEdge")
16716 case "cursor":
16717
16718 out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
16719
16720 if out.Values[i] == graphql.Null {
16721 invalids++
16722 }
16723 case "node":
16724
16725 out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
16726
16727 if out.Values[i] == graphql.Null {
16728 invalids++
16729 }
16730 default:
16731 panic("unknown field " + strconv.Quote(field.Name))
16732 }
16733 }
16734 out.Dispatch()
16735 if invalids > 0 {
16736 return graphql.Null
16737 }
16738 return out
16739}
16740
16741var labelImplementors = []string{"Label"}
16742
16743func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
16744 fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
16745 out := graphql.NewFieldSet(fields)
16746 var invalids uint32
16747 for i, field := range fields {
16748 switch field.Name {
16749 case "__typename":
16750 out.Values[i] = graphql.MarshalString("Label")
16751 case "name":
16752 field := field
16753
16754 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16755 defer func() {
16756 if r := recover(); r != nil {
16757 ec.Error(ctx, ec.Recover(ctx, r))
16758 }
16759 }()
16760 res = ec._Label_name(ctx, field, obj)
16761 if res == graphql.Null {
16762 atomic.AddUint32(&invalids, 1)
16763 }
16764 return res
16765 }
16766
16767 out.Concurrently(i, func() graphql.Marshaler {
16768 return innerFunc(ctx)
16769
16770 })
16771 case "color":
16772 field := field
16773
16774 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16775 defer func() {
16776 if r := recover(); r != nil {
16777 ec.Error(ctx, ec.Recover(ctx, r))
16778 }
16779 }()
16780 res = ec._Label_color(ctx, field, obj)
16781 if res == graphql.Null {
16782 atomic.AddUint32(&invalids, 1)
16783 }
16784 return res
16785 }
16786
16787 out.Concurrently(i, func() graphql.Marshaler {
16788 return innerFunc(ctx)
16789
16790 })
16791 default:
16792 panic("unknown field " + strconv.Quote(field.Name))
16793 }
16794 }
16795 out.Dispatch()
16796 if invalids > 0 {
16797 return graphql.Null
16798 }
16799 return out
16800}
16801
16802var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
16803
16804func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
16805 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
16806 out := graphql.NewFieldSet(fields)
16807 var invalids uint32
16808 for i, field := range fields {
16809 switch field.Name {
16810 case "__typename":
16811 out.Values[i] = graphql.MarshalString("LabelChangeOperation")
16812 case "id":
16813 field := field
16814
16815 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16816 defer func() {
16817 if r := recover(); r != nil {
16818 ec.Error(ctx, ec.Recover(ctx, r))
16819 }
16820 }()
16821 res = ec._LabelChangeOperation_id(ctx, field, obj)
16822 if res == graphql.Null {
16823 atomic.AddUint32(&invalids, 1)
16824 }
16825 return res
16826 }
16827
16828 out.Concurrently(i, func() graphql.Marshaler {
16829 return innerFunc(ctx)
16830
16831 })
16832 case "author":
16833 field := field
16834
16835 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16836 defer func() {
16837 if r := recover(); r != nil {
16838 ec.Error(ctx, ec.Recover(ctx, r))
16839 }
16840 }()
16841 res = ec._LabelChangeOperation_author(ctx, field, obj)
16842 if res == graphql.Null {
16843 atomic.AddUint32(&invalids, 1)
16844 }
16845 return res
16846 }
16847
16848 out.Concurrently(i, func() graphql.Marshaler {
16849 return innerFunc(ctx)
16850
16851 })
16852 case "date":
16853 field := field
16854
16855 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16856 defer func() {
16857 if r := recover(); r != nil {
16858 ec.Error(ctx, ec.Recover(ctx, r))
16859 }
16860 }()
16861 res = ec._LabelChangeOperation_date(ctx, field, obj)
16862 if res == graphql.Null {
16863 atomic.AddUint32(&invalids, 1)
16864 }
16865 return res
16866 }
16867
16868 out.Concurrently(i, func() graphql.Marshaler {
16869 return innerFunc(ctx)
16870
16871 })
16872 case "added":
16873
16874 out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
16875
16876 if out.Values[i] == graphql.Null {
16877 atomic.AddUint32(&invalids, 1)
16878 }
16879 case "removed":
16880
16881 out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
16882
16883 if out.Values[i] == graphql.Null {
16884 atomic.AddUint32(&invalids, 1)
16885 }
16886 default:
16887 panic("unknown field " + strconv.Quote(field.Name))
16888 }
16889 }
16890 out.Dispatch()
16891 if invalids > 0 {
16892 return graphql.Null
16893 }
16894 return out
16895}
16896
16897var labelChangeResultImplementors = []string{"LabelChangeResult"}
16898
16899func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
16900 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
16901 out := graphql.NewFieldSet(fields)
16902 var invalids uint32
16903 for i, field := range fields {
16904 switch field.Name {
16905 case "__typename":
16906 out.Values[i] = graphql.MarshalString("LabelChangeResult")
16907 case "label":
16908
16909 out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
16910
16911 if out.Values[i] == graphql.Null {
16912 atomic.AddUint32(&invalids, 1)
16913 }
16914 case "status":
16915 field := field
16916
16917 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16918 defer func() {
16919 if r := recover(); r != nil {
16920 ec.Error(ctx, ec.Recover(ctx, r))
16921 }
16922 }()
16923 res = ec._LabelChangeResult_status(ctx, field, obj)
16924 if res == graphql.Null {
16925 atomic.AddUint32(&invalids, 1)
16926 }
16927 return res
16928 }
16929
16930 out.Concurrently(i, func() graphql.Marshaler {
16931 return innerFunc(ctx)
16932
16933 })
16934 default:
16935 panic("unknown field " + strconv.Quote(field.Name))
16936 }
16937 }
16938 out.Dispatch()
16939 if invalids > 0 {
16940 return graphql.Null
16941 }
16942 return out
16943}
16944
16945var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
16946
16947func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
16948 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
16949 out := graphql.NewFieldSet(fields)
16950 var invalids uint32
16951 for i, field := range fields {
16952 switch field.Name {
16953 case "__typename":
16954 out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
16955 case "id":
16956 field := field
16957
16958 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16959 defer func() {
16960 if r := recover(); r != nil {
16961 ec.Error(ctx, ec.Recover(ctx, r))
16962 }
16963 }()
16964 res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
16965 if res == graphql.Null {
16966 atomic.AddUint32(&invalids, 1)
16967 }
16968 return res
16969 }
16970
16971 out.Concurrently(i, func() graphql.Marshaler {
16972 return innerFunc(ctx)
16973
16974 })
16975 case "author":
16976 field := field
16977
16978 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16979 defer func() {
16980 if r := recover(); r != nil {
16981 ec.Error(ctx, ec.Recover(ctx, r))
16982 }
16983 }()
16984 res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
16985 if res == graphql.Null {
16986 atomic.AddUint32(&invalids, 1)
16987 }
16988 return res
16989 }
16990
16991 out.Concurrently(i, func() graphql.Marshaler {
16992 return innerFunc(ctx)
16993
16994 })
16995 case "date":
16996 field := field
16997
16998 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
16999 defer func() {
17000 if r := recover(); r != nil {
17001 ec.Error(ctx, ec.Recover(ctx, r))
17002 }
17003 }()
17004 res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
17005 if res == graphql.Null {
17006 atomic.AddUint32(&invalids, 1)
17007 }
17008 return res
17009 }
17010
17011 out.Concurrently(i, func() graphql.Marshaler {
17012 return innerFunc(ctx)
17013
17014 })
17015 case "added":
17016
17017 out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
17018
17019 if out.Values[i] == graphql.Null {
17020 atomic.AddUint32(&invalids, 1)
17021 }
17022 case "removed":
17023
17024 out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
17025
17026 if out.Values[i] == graphql.Null {
17027 atomic.AddUint32(&invalids, 1)
17028 }
17029 default:
17030 panic("unknown field " + strconv.Quote(field.Name))
17031 }
17032 }
17033 out.Dispatch()
17034 if invalids > 0 {
17035 return graphql.Null
17036 }
17037 return out
17038}
17039
17040var labelConnectionImplementors = []string{"LabelConnection"}
17041
17042func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
17043 fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
17044 out := graphql.NewFieldSet(fields)
17045 var invalids uint32
17046 for i, field := range fields {
17047 switch field.Name {
17048 case "__typename":
17049 out.Values[i] = graphql.MarshalString("LabelConnection")
17050 case "edges":
17051
17052 out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
17053
17054 if out.Values[i] == graphql.Null {
17055 invalids++
17056 }
17057 case "nodes":
17058
17059 out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
17060
17061 if out.Values[i] == graphql.Null {
17062 invalids++
17063 }
17064 case "pageInfo":
17065
17066 out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
17067
17068 if out.Values[i] == graphql.Null {
17069 invalids++
17070 }
17071 case "totalCount":
17072
17073 out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
17074
17075 if out.Values[i] == graphql.Null {
17076 invalids++
17077 }
17078 default:
17079 panic("unknown field " + strconv.Quote(field.Name))
17080 }
17081 }
17082 out.Dispatch()
17083 if invalids > 0 {
17084 return graphql.Null
17085 }
17086 return out
17087}
17088
17089var labelEdgeImplementors = []string{"LabelEdge"}
17090
17091func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
17092 fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
17093 out := graphql.NewFieldSet(fields)
17094 var invalids uint32
17095 for i, field := range fields {
17096 switch field.Name {
17097 case "__typename":
17098 out.Values[i] = graphql.MarshalString("LabelEdge")
17099 case "cursor":
17100
17101 out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
17102
17103 if out.Values[i] == graphql.Null {
17104 invalids++
17105 }
17106 case "node":
17107
17108 out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
17109
17110 if out.Values[i] == graphql.Null {
17111 invalids++
17112 }
17113 default:
17114 panic("unknown field " + strconv.Quote(field.Name))
17115 }
17116 }
17117 out.Dispatch()
17118 if invalids > 0 {
17119 return graphql.Null
17120 }
17121 return out
17122}
17123
17124var mutationImplementors = []string{"Mutation"}
17125
17126func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
17127 fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
17128 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
17129 Object: "Mutation",
17130 })
17131
17132 out := graphql.NewFieldSet(fields)
17133 var invalids uint32
17134 for i, field := range fields {
17135 innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
17136 Object: field.Name,
17137 Field: field,
17138 })
17139
17140 switch field.Name {
17141 case "__typename":
17142 out.Values[i] = graphql.MarshalString("Mutation")
17143 case "newBug":
17144
17145 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
17146 return ec._Mutation_newBug(ctx, field)
17147 })
17148
17149 if out.Values[i] == graphql.Null {
17150 invalids++
17151 }
17152 case "addComment":
17153
17154 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
17155 return ec._Mutation_addComment(ctx, field)
17156 })
17157
17158 if out.Values[i] == graphql.Null {
17159 invalids++
17160 }
17161 case "addCommentAndClose":
17162
17163 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
17164 return ec._Mutation_addCommentAndClose(ctx, field)
17165 })
17166
17167 if out.Values[i] == graphql.Null {
17168 invalids++
17169 }
17170 case "addCommentAndReopen":
17171
17172 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
17173 return ec._Mutation_addCommentAndReopen(ctx, field)
17174 })
17175
17176 if out.Values[i] == graphql.Null {
17177 invalids++
17178 }
17179 case "editComment":
17180
17181 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
17182 return ec._Mutation_editComment(ctx, field)
17183 })
17184
17185 if out.Values[i] == graphql.Null {
17186 invalids++
17187 }
17188 case "changeLabels":
17189
17190 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
17191 return ec._Mutation_changeLabels(ctx, field)
17192 })
17193
17194 if out.Values[i] == graphql.Null {
17195 invalids++
17196 }
17197 case "openBug":
17198
17199 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
17200 return ec._Mutation_openBug(ctx, field)
17201 })
17202
17203 if out.Values[i] == graphql.Null {
17204 invalids++
17205 }
17206 case "closeBug":
17207
17208 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
17209 return ec._Mutation_closeBug(ctx, field)
17210 })
17211
17212 if out.Values[i] == graphql.Null {
17213 invalids++
17214 }
17215 case "setTitle":
17216
17217 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
17218 return ec._Mutation_setTitle(ctx, field)
17219 })
17220
17221 if out.Values[i] == graphql.Null {
17222 invalids++
17223 }
17224 default:
17225 panic("unknown field " + strconv.Quote(field.Name))
17226 }
17227 }
17228 out.Dispatch()
17229 if invalids > 0 {
17230 return graphql.Null
17231 }
17232 return out
17233}
17234
17235var newBugPayloadImplementors = []string{"NewBugPayload"}
17236
17237func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
17238 fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
17239 out := graphql.NewFieldSet(fields)
17240 var invalids uint32
17241 for i, field := range fields {
17242 switch field.Name {
17243 case "__typename":
17244 out.Values[i] = graphql.MarshalString("NewBugPayload")
17245 case "clientMutationId":
17246
17247 out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
17248
17249 case "bug":
17250
17251 out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
17252
17253 if out.Values[i] == graphql.Null {
17254 invalids++
17255 }
17256 case "operation":
17257
17258 out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
17259
17260 if out.Values[i] == graphql.Null {
17261 invalids++
17262 }
17263 default:
17264 panic("unknown field " + strconv.Quote(field.Name))
17265 }
17266 }
17267 out.Dispatch()
17268 if invalids > 0 {
17269 return graphql.Null
17270 }
17271 return out
17272}
17273
17274var openBugPayloadImplementors = []string{"OpenBugPayload"}
17275
17276func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
17277 fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
17278 out := graphql.NewFieldSet(fields)
17279 var invalids uint32
17280 for i, field := range fields {
17281 switch field.Name {
17282 case "__typename":
17283 out.Values[i] = graphql.MarshalString("OpenBugPayload")
17284 case "clientMutationId":
17285
17286 out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
17287
17288 case "bug":
17289
17290 out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
17291
17292 if out.Values[i] == graphql.Null {
17293 invalids++
17294 }
17295 case "operation":
17296
17297 out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
17298
17299 if out.Values[i] == graphql.Null {
17300 invalids++
17301 }
17302 default:
17303 panic("unknown field " + strconv.Quote(field.Name))
17304 }
17305 }
17306 out.Dispatch()
17307 if invalids > 0 {
17308 return graphql.Null
17309 }
17310 return out
17311}
17312
17313var operationConnectionImplementors = []string{"OperationConnection"}
17314
17315func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
17316 fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
17317 out := graphql.NewFieldSet(fields)
17318 var invalids uint32
17319 for i, field := range fields {
17320 switch field.Name {
17321 case "__typename":
17322 out.Values[i] = graphql.MarshalString("OperationConnection")
17323 case "edges":
17324
17325 out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
17326
17327 if out.Values[i] == graphql.Null {
17328 invalids++
17329 }
17330 case "nodes":
17331
17332 out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
17333
17334 if out.Values[i] == graphql.Null {
17335 invalids++
17336 }
17337 case "pageInfo":
17338
17339 out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
17340
17341 if out.Values[i] == graphql.Null {
17342 invalids++
17343 }
17344 case "totalCount":
17345
17346 out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
17347
17348 if out.Values[i] == graphql.Null {
17349 invalids++
17350 }
17351 default:
17352 panic("unknown field " + strconv.Quote(field.Name))
17353 }
17354 }
17355 out.Dispatch()
17356 if invalids > 0 {
17357 return graphql.Null
17358 }
17359 return out
17360}
17361
17362var operationEdgeImplementors = []string{"OperationEdge"}
17363
17364func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
17365 fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
17366 out := graphql.NewFieldSet(fields)
17367 var invalids uint32
17368 for i, field := range fields {
17369 switch field.Name {
17370 case "__typename":
17371 out.Values[i] = graphql.MarshalString("OperationEdge")
17372 case "cursor":
17373
17374 out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
17375
17376 if out.Values[i] == graphql.Null {
17377 invalids++
17378 }
17379 case "node":
17380
17381 out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
17382
17383 if out.Values[i] == graphql.Null {
17384 invalids++
17385 }
17386 default:
17387 panic("unknown field " + strconv.Quote(field.Name))
17388 }
17389 }
17390 out.Dispatch()
17391 if invalids > 0 {
17392 return graphql.Null
17393 }
17394 return out
17395}
17396
17397var pageInfoImplementors = []string{"PageInfo"}
17398
17399func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
17400 fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
17401 out := graphql.NewFieldSet(fields)
17402 var invalids uint32
17403 for i, field := range fields {
17404 switch field.Name {
17405 case "__typename":
17406 out.Values[i] = graphql.MarshalString("PageInfo")
17407 case "hasNextPage":
17408
17409 out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
17410
17411 if out.Values[i] == graphql.Null {
17412 invalids++
17413 }
17414 case "hasPreviousPage":
17415
17416 out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
17417
17418 if out.Values[i] == graphql.Null {
17419 invalids++
17420 }
17421 case "startCursor":
17422
17423 out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
17424
17425 if out.Values[i] == graphql.Null {
17426 invalids++
17427 }
17428 case "endCursor":
17429
17430 out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
17431
17432 if out.Values[i] == graphql.Null {
17433 invalids++
17434 }
17435 default:
17436 panic("unknown field " + strconv.Quote(field.Name))
17437 }
17438 }
17439 out.Dispatch()
17440 if invalids > 0 {
17441 return graphql.Null
17442 }
17443 return out
17444}
17445
17446var queryImplementors = []string{"Query"}
17447
17448func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
17449 fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
17450 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
17451 Object: "Query",
17452 })
17453
17454 out := graphql.NewFieldSet(fields)
17455 var invalids uint32
17456 for i, field := range fields {
17457 innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
17458 Object: field.Name,
17459 Field: field,
17460 })
17461
17462 switch field.Name {
17463 case "__typename":
17464 out.Values[i] = graphql.MarshalString("Query")
17465 case "repository":
17466 field := field
17467
17468 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17469 defer func() {
17470 if r := recover(); r != nil {
17471 ec.Error(ctx, ec.Recover(ctx, r))
17472 }
17473 }()
17474 res = ec._Query_repository(ctx, field)
17475 return res
17476 }
17477
17478 rrm := func(ctx context.Context) graphql.Marshaler {
17479 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
17480 }
17481
17482 out.Concurrently(i, func() graphql.Marshaler {
17483 return rrm(innerCtx)
17484 })
17485 case "__type":
17486
17487 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
17488 return ec._Query___type(ctx, field)
17489 })
17490
17491 case "__schema":
17492
17493 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
17494 return ec._Query___schema(ctx, field)
17495 })
17496
17497 default:
17498 panic("unknown field " + strconv.Quote(field.Name))
17499 }
17500 }
17501 out.Dispatch()
17502 if invalids > 0 {
17503 return graphql.Null
17504 }
17505 return out
17506}
17507
17508var repositoryImplementors = []string{"Repository"}
17509
17510func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
17511 fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
17512 out := graphql.NewFieldSet(fields)
17513 var invalids uint32
17514 for i, field := range fields {
17515 switch field.Name {
17516 case "__typename":
17517 out.Values[i] = graphql.MarshalString("Repository")
17518 case "name":
17519 field := field
17520
17521 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17522 defer func() {
17523 if r := recover(); r != nil {
17524 ec.Error(ctx, ec.Recover(ctx, r))
17525 }
17526 }()
17527 res = ec._Repository_name(ctx, field, obj)
17528 return res
17529 }
17530
17531 out.Concurrently(i, func() graphql.Marshaler {
17532 return innerFunc(ctx)
17533
17534 })
17535 case "allBugs":
17536 field := field
17537
17538 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17539 defer func() {
17540 if r := recover(); r != nil {
17541 ec.Error(ctx, ec.Recover(ctx, r))
17542 }
17543 }()
17544 res = ec._Repository_allBugs(ctx, field, obj)
17545 if res == graphql.Null {
17546 atomic.AddUint32(&invalids, 1)
17547 }
17548 return res
17549 }
17550
17551 out.Concurrently(i, func() graphql.Marshaler {
17552 return innerFunc(ctx)
17553
17554 })
17555 case "bug":
17556 field := field
17557
17558 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17559 defer func() {
17560 if r := recover(); r != nil {
17561 ec.Error(ctx, ec.Recover(ctx, r))
17562 }
17563 }()
17564 res = ec._Repository_bug(ctx, field, obj)
17565 return res
17566 }
17567
17568 out.Concurrently(i, func() graphql.Marshaler {
17569 return innerFunc(ctx)
17570
17571 })
17572 case "allIdentities":
17573 field := field
17574
17575 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17576 defer func() {
17577 if r := recover(); r != nil {
17578 ec.Error(ctx, ec.Recover(ctx, r))
17579 }
17580 }()
17581 res = ec._Repository_allIdentities(ctx, field, obj)
17582 if res == graphql.Null {
17583 atomic.AddUint32(&invalids, 1)
17584 }
17585 return res
17586 }
17587
17588 out.Concurrently(i, func() graphql.Marshaler {
17589 return innerFunc(ctx)
17590
17591 })
17592 case "identity":
17593 field := field
17594
17595 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17596 defer func() {
17597 if r := recover(); r != nil {
17598 ec.Error(ctx, ec.Recover(ctx, r))
17599 }
17600 }()
17601 res = ec._Repository_identity(ctx, field, obj)
17602 return res
17603 }
17604
17605 out.Concurrently(i, func() graphql.Marshaler {
17606 return innerFunc(ctx)
17607
17608 })
17609 case "userIdentity":
17610 field := field
17611
17612 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17613 defer func() {
17614 if r := recover(); r != nil {
17615 ec.Error(ctx, ec.Recover(ctx, r))
17616 }
17617 }()
17618 res = ec._Repository_userIdentity(ctx, field, obj)
17619 return res
17620 }
17621
17622 out.Concurrently(i, func() graphql.Marshaler {
17623 return innerFunc(ctx)
17624
17625 })
17626 case "validLabels":
17627 field := field
17628
17629 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17630 defer func() {
17631 if r := recover(); r != nil {
17632 ec.Error(ctx, ec.Recover(ctx, r))
17633 }
17634 }()
17635 res = ec._Repository_validLabels(ctx, field, obj)
17636 if res == graphql.Null {
17637 atomic.AddUint32(&invalids, 1)
17638 }
17639 return res
17640 }
17641
17642 out.Concurrently(i, func() graphql.Marshaler {
17643 return innerFunc(ctx)
17644
17645 })
17646 default:
17647 panic("unknown field " + strconv.Quote(field.Name))
17648 }
17649 }
17650 out.Dispatch()
17651 if invalids > 0 {
17652 return graphql.Null
17653 }
17654 return out
17655}
17656
17657var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
17658
17659func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
17660 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
17661 out := graphql.NewFieldSet(fields)
17662 var invalids uint32
17663 for i, field := range fields {
17664 switch field.Name {
17665 case "__typename":
17666 out.Values[i] = graphql.MarshalString("SetStatusOperation")
17667 case "id":
17668 field := field
17669
17670 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17671 defer func() {
17672 if r := recover(); r != nil {
17673 ec.Error(ctx, ec.Recover(ctx, r))
17674 }
17675 }()
17676 res = ec._SetStatusOperation_id(ctx, field, obj)
17677 if res == graphql.Null {
17678 atomic.AddUint32(&invalids, 1)
17679 }
17680 return res
17681 }
17682
17683 out.Concurrently(i, func() graphql.Marshaler {
17684 return innerFunc(ctx)
17685
17686 })
17687 case "author":
17688 field := field
17689
17690 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17691 defer func() {
17692 if r := recover(); r != nil {
17693 ec.Error(ctx, ec.Recover(ctx, r))
17694 }
17695 }()
17696 res = ec._SetStatusOperation_author(ctx, field, obj)
17697 if res == graphql.Null {
17698 atomic.AddUint32(&invalids, 1)
17699 }
17700 return res
17701 }
17702
17703 out.Concurrently(i, func() graphql.Marshaler {
17704 return innerFunc(ctx)
17705
17706 })
17707 case "date":
17708 field := field
17709
17710 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17711 defer func() {
17712 if r := recover(); r != nil {
17713 ec.Error(ctx, ec.Recover(ctx, r))
17714 }
17715 }()
17716 res = ec._SetStatusOperation_date(ctx, field, obj)
17717 if res == graphql.Null {
17718 atomic.AddUint32(&invalids, 1)
17719 }
17720 return res
17721 }
17722
17723 out.Concurrently(i, func() graphql.Marshaler {
17724 return innerFunc(ctx)
17725
17726 })
17727 case "status":
17728 field := field
17729
17730 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17731 defer func() {
17732 if r := recover(); r != nil {
17733 ec.Error(ctx, ec.Recover(ctx, r))
17734 }
17735 }()
17736 res = ec._SetStatusOperation_status(ctx, field, obj)
17737 if res == graphql.Null {
17738 atomic.AddUint32(&invalids, 1)
17739 }
17740 return res
17741 }
17742
17743 out.Concurrently(i, func() graphql.Marshaler {
17744 return innerFunc(ctx)
17745
17746 })
17747 default:
17748 panic("unknown field " + strconv.Quote(field.Name))
17749 }
17750 }
17751 out.Dispatch()
17752 if invalids > 0 {
17753 return graphql.Null
17754 }
17755 return out
17756}
17757
17758var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
17759
17760func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
17761 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
17762 out := graphql.NewFieldSet(fields)
17763 var invalids uint32
17764 for i, field := range fields {
17765 switch field.Name {
17766 case "__typename":
17767 out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
17768 case "id":
17769 field := field
17770
17771 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17772 defer func() {
17773 if r := recover(); r != nil {
17774 ec.Error(ctx, ec.Recover(ctx, r))
17775 }
17776 }()
17777 res = ec._SetStatusTimelineItem_id(ctx, field, obj)
17778 if res == graphql.Null {
17779 atomic.AddUint32(&invalids, 1)
17780 }
17781 return res
17782 }
17783
17784 out.Concurrently(i, func() graphql.Marshaler {
17785 return innerFunc(ctx)
17786
17787 })
17788 case "author":
17789 field := field
17790
17791 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17792 defer func() {
17793 if r := recover(); r != nil {
17794 ec.Error(ctx, ec.Recover(ctx, r))
17795 }
17796 }()
17797 res = ec._SetStatusTimelineItem_author(ctx, field, obj)
17798 if res == graphql.Null {
17799 atomic.AddUint32(&invalids, 1)
17800 }
17801 return res
17802 }
17803
17804 out.Concurrently(i, func() graphql.Marshaler {
17805 return innerFunc(ctx)
17806
17807 })
17808 case "date":
17809 field := field
17810
17811 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17812 defer func() {
17813 if r := recover(); r != nil {
17814 ec.Error(ctx, ec.Recover(ctx, r))
17815 }
17816 }()
17817 res = ec._SetStatusTimelineItem_date(ctx, field, obj)
17818 if res == graphql.Null {
17819 atomic.AddUint32(&invalids, 1)
17820 }
17821 return res
17822 }
17823
17824 out.Concurrently(i, func() graphql.Marshaler {
17825 return innerFunc(ctx)
17826
17827 })
17828 case "status":
17829 field := field
17830
17831 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17832 defer func() {
17833 if r := recover(); r != nil {
17834 ec.Error(ctx, ec.Recover(ctx, r))
17835 }
17836 }()
17837 res = ec._SetStatusTimelineItem_status(ctx, field, obj)
17838 if res == graphql.Null {
17839 atomic.AddUint32(&invalids, 1)
17840 }
17841 return res
17842 }
17843
17844 out.Concurrently(i, func() graphql.Marshaler {
17845 return innerFunc(ctx)
17846
17847 })
17848 default:
17849 panic("unknown field " + strconv.Quote(field.Name))
17850 }
17851 }
17852 out.Dispatch()
17853 if invalids > 0 {
17854 return graphql.Null
17855 }
17856 return out
17857}
17858
17859var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
17860
17861func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
17862 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
17863 out := graphql.NewFieldSet(fields)
17864 var invalids uint32
17865 for i, field := range fields {
17866 switch field.Name {
17867 case "__typename":
17868 out.Values[i] = graphql.MarshalString("SetTitleOperation")
17869 case "id":
17870 field := field
17871
17872 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17873 defer func() {
17874 if r := recover(); r != nil {
17875 ec.Error(ctx, ec.Recover(ctx, r))
17876 }
17877 }()
17878 res = ec._SetTitleOperation_id(ctx, field, obj)
17879 if res == graphql.Null {
17880 atomic.AddUint32(&invalids, 1)
17881 }
17882 return res
17883 }
17884
17885 out.Concurrently(i, func() graphql.Marshaler {
17886 return innerFunc(ctx)
17887
17888 })
17889 case "author":
17890 field := field
17891
17892 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17893 defer func() {
17894 if r := recover(); r != nil {
17895 ec.Error(ctx, ec.Recover(ctx, r))
17896 }
17897 }()
17898 res = ec._SetTitleOperation_author(ctx, field, obj)
17899 if res == graphql.Null {
17900 atomic.AddUint32(&invalids, 1)
17901 }
17902 return res
17903 }
17904
17905 out.Concurrently(i, func() graphql.Marshaler {
17906 return innerFunc(ctx)
17907
17908 })
17909 case "date":
17910 field := field
17911
17912 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
17913 defer func() {
17914 if r := recover(); r != nil {
17915 ec.Error(ctx, ec.Recover(ctx, r))
17916 }
17917 }()
17918 res = ec._SetTitleOperation_date(ctx, field, obj)
17919 if res == graphql.Null {
17920 atomic.AddUint32(&invalids, 1)
17921 }
17922 return res
17923 }
17924
17925 out.Concurrently(i, func() graphql.Marshaler {
17926 return innerFunc(ctx)
17927
17928 })
17929 case "title":
17930
17931 out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
17932
17933 if out.Values[i] == graphql.Null {
17934 atomic.AddUint32(&invalids, 1)
17935 }
17936 case "was":
17937
17938 out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
17939
17940 if out.Values[i] == graphql.Null {
17941 atomic.AddUint32(&invalids, 1)
17942 }
17943 default:
17944 panic("unknown field " + strconv.Quote(field.Name))
17945 }
17946 }
17947 out.Dispatch()
17948 if invalids > 0 {
17949 return graphql.Null
17950 }
17951 return out
17952}
17953
17954var setTitlePayloadImplementors = []string{"SetTitlePayload"}
17955
17956func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
17957 fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
17958 out := graphql.NewFieldSet(fields)
17959 var invalids uint32
17960 for i, field := range fields {
17961 switch field.Name {
17962 case "__typename":
17963 out.Values[i] = graphql.MarshalString("SetTitlePayload")
17964 case "clientMutationId":
17965
17966 out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
17967
17968 case "bug":
17969
17970 out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
17971
17972 if out.Values[i] == graphql.Null {
17973 invalids++
17974 }
17975 case "operation":
17976
17977 out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
17978
17979 if out.Values[i] == graphql.Null {
17980 invalids++
17981 }
17982 default:
17983 panic("unknown field " + strconv.Quote(field.Name))
17984 }
17985 }
17986 out.Dispatch()
17987 if invalids > 0 {
17988 return graphql.Null
17989 }
17990 return out
17991}
17992
17993var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
17994
17995func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
17996 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
17997 out := graphql.NewFieldSet(fields)
17998 var invalids uint32
17999 for i, field := range fields {
18000 switch field.Name {
18001 case "__typename":
18002 out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
18003 case "id":
18004 field := field
18005
18006 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
18007 defer func() {
18008 if r := recover(); r != nil {
18009 ec.Error(ctx, ec.Recover(ctx, r))
18010 }
18011 }()
18012 res = ec._SetTitleTimelineItem_id(ctx, field, obj)
18013 if res == graphql.Null {
18014 atomic.AddUint32(&invalids, 1)
18015 }
18016 return res
18017 }
18018
18019 out.Concurrently(i, func() graphql.Marshaler {
18020 return innerFunc(ctx)
18021
18022 })
18023 case "author":
18024 field := field
18025
18026 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
18027 defer func() {
18028 if r := recover(); r != nil {
18029 ec.Error(ctx, ec.Recover(ctx, r))
18030 }
18031 }()
18032 res = ec._SetTitleTimelineItem_author(ctx, field, obj)
18033 if res == graphql.Null {
18034 atomic.AddUint32(&invalids, 1)
18035 }
18036 return res
18037 }
18038
18039 out.Concurrently(i, func() graphql.Marshaler {
18040 return innerFunc(ctx)
18041
18042 })
18043 case "date":
18044 field := field
18045
18046 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
18047 defer func() {
18048 if r := recover(); r != nil {
18049 ec.Error(ctx, ec.Recover(ctx, r))
18050 }
18051 }()
18052 res = ec._SetTitleTimelineItem_date(ctx, field, obj)
18053 if res == graphql.Null {
18054 atomic.AddUint32(&invalids, 1)
18055 }
18056 return res
18057 }
18058
18059 out.Concurrently(i, func() graphql.Marshaler {
18060 return innerFunc(ctx)
18061
18062 })
18063 case "title":
18064
18065 out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
18066
18067 if out.Values[i] == graphql.Null {
18068 atomic.AddUint32(&invalids, 1)
18069 }
18070 case "was":
18071
18072 out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
18073
18074 if out.Values[i] == graphql.Null {
18075 atomic.AddUint32(&invalids, 1)
18076 }
18077 default:
18078 panic("unknown field " + strconv.Quote(field.Name))
18079 }
18080 }
18081 out.Dispatch()
18082 if invalids > 0 {
18083 return graphql.Null
18084 }
18085 return out
18086}
18087
18088var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
18089
18090func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
18091 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
18092 out := graphql.NewFieldSet(fields)
18093 var invalids uint32
18094 for i, field := range fields {
18095 switch field.Name {
18096 case "__typename":
18097 out.Values[i] = graphql.MarshalString("TimelineItemConnection")
18098 case "edges":
18099
18100 out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
18101
18102 if out.Values[i] == graphql.Null {
18103 invalids++
18104 }
18105 case "nodes":
18106
18107 out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
18108
18109 if out.Values[i] == graphql.Null {
18110 invalids++
18111 }
18112 case "pageInfo":
18113
18114 out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
18115
18116 if out.Values[i] == graphql.Null {
18117 invalids++
18118 }
18119 case "totalCount":
18120
18121 out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
18122
18123 if out.Values[i] == graphql.Null {
18124 invalids++
18125 }
18126 default:
18127 panic("unknown field " + strconv.Quote(field.Name))
18128 }
18129 }
18130 out.Dispatch()
18131 if invalids > 0 {
18132 return graphql.Null
18133 }
18134 return out
18135}
18136
18137var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
18138
18139func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
18140 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
18141 out := graphql.NewFieldSet(fields)
18142 var invalids uint32
18143 for i, field := range fields {
18144 switch field.Name {
18145 case "__typename":
18146 out.Values[i] = graphql.MarshalString("TimelineItemEdge")
18147 case "cursor":
18148
18149 out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
18150
18151 if out.Values[i] == graphql.Null {
18152 invalids++
18153 }
18154 case "node":
18155
18156 out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
18157
18158 if out.Values[i] == graphql.Null {
18159 invalids++
18160 }
18161 default:
18162 panic("unknown field " + strconv.Quote(field.Name))
18163 }
18164 }
18165 out.Dispatch()
18166 if invalids > 0 {
18167 return graphql.Null
18168 }
18169 return out
18170}
18171
18172var __DirectiveImplementors = []string{"__Directive"}
18173
18174func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
18175 fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
18176 out := graphql.NewFieldSet(fields)
18177 var invalids uint32
18178 for i, field := range fields {
18179 switch field.Name {
18180 case "__typename":
18181 out.Values[i] = graphql.MarshalString("__Directive")
18182 case "name":
18183
18184 out.Values[i] = ec.___Directive_name(ctx, field, obj)
18185
18186 if out.Values[i] == graphql.Null {
18187 invalids++
18188 }
18189 case "description":
18190
18191 out.Values[i] = ec.___Directive_description(ctx, field, obj)
18192
18193 case "locations":
18194
18195 out.Values[i] = ec.___Directive_locations(ctx, field, obj)
18196
18197 if out.Values[i] == graphql.Null {
18198 invalids++
18199 }
18200 case "args":
18201
18202 out.Values[i] = ec.___Directive_args(ctx, field, obj)
18203
18204 if out.Values[i] == graphql.Null {
18205 invalids++
18206 }
18207 case "isRepeatable":
18208
18209 out.Values[i] = ec.___Directive_isRepeatable(ctx, field, obj)
18210
18211 if out.Values[i] == graphql.Null {
18212 invalids++
18213 }
18214 default:
18215 panic("unknown field " + strconv.Quote(field.Name))
18216 }
18217 }
18218 out.Dispatch()
18219 if invalids > 0 {
18220 return graphql.Null
18221 }
18222 return out
18223}
18224
18225var __EnumValueImplementors = []string{"__EnumValue"}
18226
18227func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
18228 fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
18229 out := graphql.NewFieldSet(fields)
18230 var invalids uint32
18231 for i, field := range fields {
18232 switch field.Name {
18233 case "__typename":
18234 out.Values[i] = graphql.MarshalString("__EnumValue")
18235 case "name":
18236
18237 out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
18238
18239 if out.Values[i] == graphql.Null {
18240 invalids++
18241 }
18242 case "description":
18243
18244 out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
18245
18246 case "isDeprecated":
18247
18248 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
18249
18250 if out.Values[i] == graphql.Null {
18251 invalids++
18252 }
18253 case "deprecationReason":
18254
18255 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
18256
18257 default:
18258 panic("unknown field " + strconv.Quote(field.Name))
18259 }
18260 }
18261 out.Dispatch()
18262 if invalids > 0 {
18263 return graphql.Null
18264 }
18265 return out
18266}
18267
18268var __FieldImplementors = []string{"__Field"}
18269
18270func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
18271 fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
18272 out := graphql.NewFieldSet(fields)
18273 var invalids uint32
18274 for i, field := range fields {
18275 switch field.Name {
18276 case "__typename":
18277 out.Values[i] = graphql.MarshalString("__Field")
18278 case "name":
18279
18280 out.Values[i] = ec.___Field_name(ctx, field, obj)
18281
18282 if out.Values[i] == graphql.Null {
18283 invalids++
18284 }
18285 case "description":
18286
18287 out.Values[i] = ec.___Field_description(ctx, field, obj)
18288
18289 case "args":
18290
18291 out.Values[i] = ec.___Field_args(ctx, field, obj)
18292
18293 if out.Values[i] == graphql.Null {
18294 invalids++
18295 }
18296 case "type":
18297
18298 out.Values[i] = ec.___Field_type(ctx, field, obj)
18299
18300 if out.Values[i] == graphql.Null {
18301 invalids++
18302 }
18303 case "isDeprecated":
18304
18305 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
18306
18307 if out.Values[i] == graphql.Null {
18308 invalids++
18309 }
18310 case "deprecationReason":
18311
18312 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
18313
18314 default:
18315 panic("unknown field " + strconv.Quote(field.Name))
18316 }
18317 }
18318 out.Dispatch()
18319 if invalids > 0 {
18320 return graphql.Null
18321 }
18322 return out
18323}
18324
18325var __InputValueImplementors = []string{"__InputValue"}
18326
18327func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
18328 fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
18329 out := graphql.NewFieldSet(fields)
18330 var invalids uint32
18331 for i, field := range fields {
18332 switch field.Name {
18333 case "__typename":
18334 out.Values[i] = graphql.MarshalString("__InputValue")
18335 case "name":
18336
18337 out.Values[i] = ec.___InputValue_name(ctx, field, obj)
18338
18339 if out.Values[i] == graphql.Null {
18340 invalids++
18341 }
18342 case "description":
18343
18344 out.Values[i] = ec.___InputValue_description(ctx, field, obj)
18345
18346 case "type":
18347
18348 out.Values[i] = ec.___InputValue_type(ctx, field, obj)
18349
18350 if out.Values[i] == graphql.Null {
18351 invalids++
18352 }
18353 case "defaultValue":
18354
18355 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
18356
18357 default:
18358 panic("unknown field " + strconv.Quote(field.Name))
18359 }
18360 }
18361 out.Dispatch()
18362 if invalids > 0 {
18363 return graphql.Null
18364 }
18365 return out
18366}
18367
18368var __SchemaImplementors = []string{"__Schema"}
18369
18370func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
18371 fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
18372 out := graphql.NewFieldSet(fields)
18373 var invalids uint32
18374 for i, field := range fields {
18375 switch field.Name {
18376 case "__typename":
18377 out.Values[i] = graphql.MarshalString("__Schema")
18378 case "description":
18379
18380 out.Values[i] = ec.___Schema_description(ctx, field, obj)
18381
18382 case "types":
18383
18384 out.Values[i] = ec.___Schema_types(ctx, field, obj)
18385
18386 if out.Values[i] == graphql.Null {
18387 invalids++
18388 }
18389 case "queryType":
18390
18391 out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
18392
18393 if out.Values[i] == graphql.Null {
18394 invalids++
18395 }
18396 case "mutationType":
18397
18398 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
18399
18400 case "subscriptionType":
18401
18402 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
18403
18404 case "directives":
18405
18406 out.Values[i] = ec.___Schema_directives(ctx, field, obj)
18407
18408 if out.Values[i] == graphql.Null {
18409 invalids++
18410 }
18411 default:
18412 panic("unknown field " + strconv.Quote(field.Name))
18413 }
18414 }
18415 out.Dispatch()
18416 if invalids > 0 {
18417 return graphql.Null
18418 }
18419 return out
18420}
18421
18422var __TypeImplementors = []string{"__Type"}
18423
18424func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
18425 fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
18426 out := graphql.NewFieldSet(fields)
18427 var invalids uint32
18428 for i, field := range fields {
18429 switch field.Name {
18430 case "__typename":
18431 out.Values[i] = graphql.MarshalString("__Type")
18432 case "kind":
18433
18434 out.Values[i] = ec.___Type_kind(ctx, field, obj)
18435
18436 if out.Values[i] == graphql.Null {
18437 invalids++
18438 }
18439 case "name":
18440
18441 out.Values[i] = ec.___Type_name(ctx, field, obj)
18442
18443 case "description":
18444
18445 out.Values[i] = ec.___Type_description(ctx, field, obj)
18446
18447 case "fields":
18448
18449 out.Values[i] = ec.___Type_fields(ctx, field, obj)
18450
18451 case "interfaces":
18452
18453 out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
18454
18455 case "possibleTypes":
18456
18457 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
18458
18459 case "enumValues":
18460
18461 out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
18462
18463 case "inputFields":
18464
18465 out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
18466
18467 case "ofType":
18468
18469 out.Values[i] = ec.___Type_ofType(ctx, field, obj)
18470
18471 case "specifiedByURL":
18472
18473 out.Values[i] = ec.___Type_specifiedByURL(ctx, field, obj)
18474
18475 default:
18476 panic("unknown field " + strconv.Quote(field.Name))
18477 }
18478 }
18479 out.Dispatch()
18480 if invalids > 0 {
18481 return graphql.Null
18482 }
18483 return out
18484}
18485
18486// endregion **************************** object.gotpl ****************************
18487
18488// region ***************************** type.gotpl *****************************
18489
18490func (ec *executionContext) unmarshalNAddCommentAndCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugInput(ctx context.Context, v interface{}) (models.AddCommentAndCloseBugInput, error) {
18491 res, err := ec.unmarshalInputAddCommentAndCloseBugInput(ctx, v)
18492 return res, graphql.ErrorOnPath(ctx, err)
18493}
18494
18495func (ec *executionContext) marshalNAddCommentAndCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentAndCloseBugPayload) graphql.Marshaler {
18496 return ec._AddCommentAndCloseBugPayload(ctx, sel, &v)
18497}
18498
18499func (ec *executionContext) marshalNAddCommentAndCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentAndCloseBugPayload) graphql.Marshaler {
18500 if v == nil {
18501 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18502 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18503 }
18504 return graphql.Null
18505 }
18506 return ec._AddCommentAndCloseBugPayload(ctx, sel, v)
18507}
18508
18509func (ec *executionContext) unmarshalNAddCommentAndReopenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugInput(ctx context.Context, v interface{}) (models.AddCommentAndReopenBugInput, error) {
18510 res, err := ec.unmarshalInputAddCommentAndReopenBugInput(ctx, v)
18511 return res, graphql.ErrorOnPath(ctx, err)
18512}
18513
18514func (ec *executionContext) marshalNAddCommentAndReopenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentAndReopenBugPayload) graphql.Marshaler {
18515 return ec._AddCommentAndReopenBugPayload(ctx, sel, &v)
18516}
18517
18518func (ec *executionContext) marshalNAddCommentAndReopenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentAndReopenBugPayload) graphql.Marshaler {
18519 if v == nil {
18520 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18521 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18522 }
18523 return graphql.Null
18524 }
18525 return ec._AddCommentAndReopenBugPayload(ctx, sel, v)
18526}
18527
18528func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
18529 res, err := ec.unmarshalInputAddCommentInput(ctx, v)
18530 return res, graphql.ErrorOnPath(ctx, err)
18531}
18532
18533func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
18534 if v == nil {
18535 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18536 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18537 }
18538 return graphql.Null
18539 }
18540 return ec._AddCommentOperation(ctx, sel, v)
18541}
18542
18543func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
18544 return ec._AddCommentPayload(ctx, sel, &v)
18545}
18546
18547func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
18548 if v == nil {
18549 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18550 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18551 }
18552 return graphql.Null
18553 }
18554 return ec._AddCommentPayload(ctx, sel, v)
18555}
18556
18557func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
18558 res, err := graphql.UnmarshalBoolean(v)
18559 return res, graphql.ErrorOnPath(ctx, err)
18560}
18561
18562func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
18563 res := graphql.MarshalBoolean(v)
18564 if res == graphql.Null {
18565 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18566 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18567 }
18568 }
18569 return res
18570}
18571
18572func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
18573 if v == nil {
18574 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18575 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18576 }
18577 return graphql.Null
18578 }
18579 return ec._Bug(ctx, sel, v)
18580}
18581
18582func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
18583 ret := make(graphql.Array, len(v))
18584 var wg sync.WaitGroup
18585 isLen1 := len(v) == 1
18586 if !isLen1 {
18587 wg.Add(len(v))
18588 }
18589 for i := range v {
18590 i := i
18591 fc := &graphql.FieldContext{
18592 Index: &i,
18593 Result: &v[i],
18594 }
18595 ctx := graphql.WithFieldContext(ctx, fc)
18596 f := func(i int) {
18597 defer func() {
18598 if r := recover(); r != nil {
18599 ec.Error(ctx, ec.Recover(ctx, r))
18600 ret = nil
18601 }
18602 }()
18603 if !isLen1 {
18604 defer wg.Done()
18605 }
18606 ret[i] = ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
18607 }
18608 if isLen1 {
18609 f(i)
18610 } else {
18611 go f(i)
18612 }
18613
18614 }
18615 wg.Wait()
18616
18617 for _, e := range ret {
18618 if e == graphql.Null {
18619 return graphql.Null
18620 }
18621 }
18622
18623 return ret
18624}
18625
18626func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
18627 return ec._BugConnection(ctx, sel, &v)
18628}
18629
18630func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
18631 if v == nil {
18632 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18633 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18634 }
18635 return graphql.Null
18636 }
18637 return ec._BugConnection(ctx, sel, v)
18638}
18639
18640func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
18641 ret := make(graphql.Array, len(v))
18642 var wg sync.WaitGroup
18643 isLen1 := len(v) == 1
18644 if !isLen1 {
18645 wg.Add(len(v))
18646 }
18647 for i := range v {
18648 i := i
18649 fc := &graphql.FieldContext{
18650 Index: &i,
18651 Result: &v[i],
18652 }
18653 ctx := graphql.WithFieldContext(ctx, fc)
18654 f := func(i int) {
18655 defer func() {
18656 if r := recover(); r != nil {
18657 ec.Error(ctx, ec.Recover(ctx, r))
18658 ret = nil
18659 }
18660 }()
18661 if !isLen1 {
18662 defer wg.Done()
18663 }
18664 ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
18665 }
18666 if isLen1 {
18667 f(i)
18668 } else {
18669 go f(i)
18670 }
18671
18672 }
18673 wg.Wait()
18674
18675 for _, e := range ret {
18676 if e == graphql.Null {
18677 return graphql.Null
18678 }
18679 }
18680
18681 return ret
18682}
18683
18684func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
18685 if v == nil {
18686 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18687 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18688 }
18689 return graphql.Null
18690 }
18691 return ec._BugEdge(ctx, sel, v)
18692}
18693
18694func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
18695 return ec._ChangeLabelPayload(ctx, sel, &v)
18696}
18697
18698func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
18699 if v == nil {
18700 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18701 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18702 }
18703 return graphql.Null
18704 }
18705 return ec._ChangeLabelPayload(ctx, sel, v)
18706}
18707
18708func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
18709 res, err := ec.unmarshalInputCloseBugInput(ctx, v)
18710 return res, graphql.ErrorOnPath(ctx, err)
18711}
18712
18713func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
18714 return ec._CloseBugPayload(ctx, sel, &v)
18715}
18716
18717func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
18718 if v == nil {
18719 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18720 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18721 }
18722 return graphql.Null
18723 }
18724 return ec._CloseBugPayload(ctx, sel, v)
18725}
18726
18727func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
18728 return ec._Color(ctx, sel, &v)
18729}
18730
18731func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
18732 if v == nil {
18733 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18734 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18735 }
18736 return graphql.Null
18737 }
18738 return ec._Color(ctx, sel, v)
18739}
18740
18741func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
18742 ret := make(graphql.Array, len(v))
18743 var wg sync.WaitGroup
18744 isLen1 := len(v) == 1
18745 if !isLen1 {
18746 wg.Add(len(v))
18747 }
18748 for i := range v {
18749 i := i
18750 fc := &graphql.FieldContext{
18751 Index: &i,
18752 Result: &v[i],
18753 }
18754 ctx := graphql.WithFieldContext(ctx, fc)
18755 f := func(i int) {
18756 defer func() {
18757 if r := recover(); r != nil {
18758 ec.Error(ctx, ec.Recover(ctx, r))
18759 ret = nil
18760 }
18761 }()
18762 if !isLen1 {
18763 defer wg.Done()
18764 }
18765 ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
18766 }
18767 if isLen1 {
18768 f(i)
18769 } else {
18770 go f(i)
18771 }
18772
18773 }
18774 wg.Wait()
18775
18776 for _, e := range ret {
18777 if e == graphql.Null {
18778 return graphql.Null
18779 }
18780 }
18781
18782 return ret
18783}
18784
18785func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
18786 if v == nil {
18787 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18788 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18789 }
18790 return graphql.Null
18791 }
18792 return ec._Comment(ctx, sel, v)
18793}
18794
18795func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
18796 return ec._CommentConnection(ctx, sel, &v)
18797}
18798
18799func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
18800 if v == nil {
18801 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18802 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18803 }
18804 return graphql.Null
18805 }
18806 return ec._CommentConnection(ctx, sel, v)
18807}
18808
18809func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
18810 ret := make(graphql.Array, len(v))
18811 var wg sync.WaitGroup
18812 isLen1 := len(v) == 1
18813 if !isLen1 {
18814 wg.Add(len(v))
18815 }
18816 for i := range v {
18817 i := i
18818 fc := &graphql.FieldContext{
18819 Index: &i,
18820 Result: &v[i],
18821 }
18822 ctx := graphql.WithFieldContext(ctx, fc)
18823 f := func(i int) {
18824 defer func() {
18825 if r := recover(); r != nil {
18826 ec.Error(ctx, ec.Recover(ctx, r))
18827 ret = nil
18828 }
18829 }()
18830 if !isLen1 {
18831 defer wg.Done()
18832 }
18833 ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
18834 }
18835 if isLen1 {
18836 f(i)
18837 } else {
18838 go f(i)
18839 }
18840
18841 }
18842 wg.Wait()
18843
18844 for _, e := range ret {
18845 if e == graphql.Null {
18846 return graphql.Null
18847 }
18848 }
18849
18850 return ret
18851}
18852
18853func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
18854 if v == nil {
18855 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18856 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18857 }
18858 return graphql.Null
18859 }
18860 return ec._CommentEdge(ctx, sel, v)
18861}
18862
18863func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
18864 return ec._CommentHistoryStep(ctx, sel, &v)
18865}
18866
18867func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
18868 ret := make(graphql.Array, len(v))
18869 var wg sync.WaitGroup
18870 isLen1 := len(v) == 1
18871 if !isLen1 {
18872 wg.Add(len(v))
18873 }
18874 for i := range v {
18875 i := i
18876 fc := &graphql.FieldContext{
18877 Index: &i,
18878 Result: &v[i],
18879 }
18880 ctx := graphql.WithFieldContext(ctx, fc)
18881 f := func(i int) {
18882 defer func() {
18883 if r := recover(); r != nil {
18884 ec.Error(ctx, ec.Recover(ctx, r))
18885 ret = nil
18886 }
18887 }()
18888 if !isLen1 {
18889 defer wg.Done()
18890 }
18891 ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
18892 }
18893 if isLen1 {
18894 f(i)
18895 } else {
18896 go f(i)
18897 }
18898
18899 }
18900 wg.Wait()
18901
18902 for _, e := range ret {
18903 if e == graphql.Null {
18904 return graphql.Null
18905 }
18906 }
18907
18908 return ret
18909}
18910
18911func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
18912 if v == nil {
18913 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18914 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18915 }
18916 return graphql.Null
18917 }
18918 return ec._CreateOperation(ctx, sel, v)
18919}
18920
18921func (ec *executionContext) unmarshalNEditCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx context.Context, v interface{}) (models.EditCommentInput, error) {
18922 res, err := ec.unmarshalInputEditCommentInput(ctx, v)
18923 return res, graphql.ErrorOnPath(ctx, err)
18924}
18925
18926func (ec *executionContext) marshalNEditCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐEditCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.EditCommentOperation) graphql.Marshaler {
18927 if v == nil {
18928 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18929 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18930 }
18931 return graphql.Null
18932 }
18933 return ec._EditCommentOperation(ctx, sel, v)
18934}
18935
18936func (ec *executionContext) marshalNEditCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.EditCommentPayload) graphql.Marshaler {
18937 return ec._EditCommentPayload(ctx, sel, &v)
18938}
18939
18940func (ec *executionContext) marshalNEditCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.EditCommentPayload) graphql.Marshaler {
18941 if v == nil {
18942 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18943 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18944 }
18945 return graphql.Null
18946 }
18947 return ec._EditCommentPayload(ctx, sel, v)
18948}
18949
18950func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx context.Context, v interface{}) (repository.Hash, error) {
18951 var res repository.Hash
18952 err := res.UnmarshalGQL(v)
18953 return res, graphql.ErrorOnPath(ctx, err)
18954}
18955
18956func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx context.Context, sel ast.SelectionSet, v repository.Hash) graphql.Marshaler {
18957 return v
18958}
18959
18960func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, v interface{}) ([]repository.Hash, error) {
18961 var vSlice []interface{}
18962 if v != nil {
18963 vSlice = graphql.CoerceList(v)
18964 }
18965 var err error
18966 res := make([]repository.Hash, len(vSlice))
18967 for i := range vSlice {
18968 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
18969 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, vSlice[i])
18970 if err != nil {
18971 return nil, err
18972 }
18973 }
18974 return res, nil
18975}
18976
18977func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []repository.Hash) graphql.Marshaler {
18978 ret := make(graphql.Array, len(v))
18979 for i := range v {
18980 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, sel, v[i])
18981 }
18982
18983 for _, e := range ret {
18984 if e == graphql.Null {
18985 return graphql.Null
18986 }
18987 }
18988
18989 return ret
18990}
18991
18992func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
18993 if v == nil {
18994 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
18995 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
18996 }
18997 return graphql.Null
18998 }
18999 return ec._Identity(ctx, sel, v)
19000}
19001
19002func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.IdentityWrapper) graphql.Marshaler {
19003 ret := make(graphql.Array, len(v))
19004 var wg sync.WaitGroup
19005 isLen1 := len(v) == 1
19006 if !isLen1 {
19007 wg.Add(len(v))
19008 }
19009 for i := range v {
19010 i := i
19011 fc := &graphql.FieldContext{
19012 Index: &i,
19013 Result: &v[i],
19014 }
19015 ctx := graphql.WithFieldContext(ctx, fc)
19016 f := func(i int) {
19017 defer func() {
19018 if r := recover(); r != nil {
19019 ec.Error(ctx, ec.Recover(ctx, r))
19020 ret = nil
19021 }
19022 }()
19023 if !isLen1 {
19024 defer wg.Done()
19025 }
19026 ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, sel, v[i])
19027 }
19028 if isLen1 {
19029 f(i)
19030 } else {
19031 go f(i)
19032 }
19033
19034 }
19035 wg.Wait()
19036
19037 for _, e := range ret {
19038 if e == graphql.Null {
19039 return graphql.Null
19040 }
19041 }
19042
19043 return ret
19044}
19045
19046func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
19047 return ec._IdentityConnection(ctx, sel, &v)
19048}
19049
19050func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
19051 if v == nil {
19052 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19053 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19054 }
19055 return graphql.Null
19056 }
19057 return ec._IdentityConnection(ctx, sel, v)
19058}
19059
19060func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
19061 ret := make(graphql.Array, len(v))
19062 var wg sync.WaitGroup
19063 isLen1 := len(v) == 1
19064 if !isLen1 {
19065 wg.Add(len(v))
19066 }
19067 for i := range v {
19068 i := i
19069 fc := &graphql.FieldContext{
19070 Index: &i,
19071 Result: &v[i],
19072 }
19073 ctx := graphql.WithFieldContext(ctx, fc)
19074 f := func(i int) {
19075 defer func() {
19076 if r := recover(); r != nil {
19077 ec.Error(ctx, ec.Recover(ctx, r))
19078 ret = nil
19079 }
19080 }()
19081 if !isLen1 {
19082 defer wg.Done()
19083 }
19084 ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
19085 }
19086 if isLen1 {
19087 f(i)
19088 } else {
19089 go f(i)
19090 }
19091
19092 }
19093 wg.Wait()
19094
19095 for _, e := range ret {
19096 if e == graphql.Null {
19097 return graphql.Null
19098 }
19099 }
19100
19101 return ret
19102}
19103
19104func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
19105 if v == nil {
19106 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19107 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19108 }
19109 return graphql.Null
19110 }
19111 return ec._IdentityEdge(ctx, sel, v)
19112}
19113
19114func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
19115 res, err := graphql.UnmarshalInt(v)
19116 return res, graphql.ErrorOnPath(ctx, err)
19117}
19118
19119func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
19120 res := graphql.MarshalInt(v)
19121 if res == graphql.Null {
19122 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19123 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19124 }
19125 }
19126 return res
19127}
19128
19129func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
19130 return ec._Label(ctx, sel, &v)
19131}
19132
19133func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
19134 ret := make(graphql.Array, len(v))
19135 var wg sync.WaitGroup
19136 isLen1 := len(v) == 1
19137 if !isLen1 {
19138 wg.Add(len(v))
19139 }
19140 for i := range v {
19141 i := i
19142 fc := &graphql.FieldContext{
19143 Index: &i,
19144 Result: &v[i],
19145 }
19146 ctx := graphql.WithFieldContext(ctx, fc)
19147 f := func(i int) {
19148 defer func() {
19149 if r := recover(); r != nil {
19150 ec.Error(ctx, ec.Recover(ctx, r))
19151 ret = nil
19152 }
19153 }()
19154 if !isLen1 {
19155 defer wg.Done()
19156 }
19157 ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
19158 }
19159 if isLen1 {
19160 f(i)
19161 } else {
19162 go f(i)
19163 }
19164
19165 }
19166 wg.Wait()
19167
19168 for _, e := range ret {
19169 if e == graphql.Null {
19170 return graphql.Null
19171 }
19172 }
19173
19174 return ret
19175}
19176
19177func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
19178 if v == nil {
19179 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19180 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19181 }
19182 return graphql.Null
19183 }
19184 return ec._LabelChangeOperation(ctx, sel, v)
19185}
19186
19187func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
19188 ret := make(graphql.Array, len(v))
19189 var wg sync.WaitGroup
19190 isLen1 := len(v) == 1
19191 if !isLen1 {
19192 wg.Add(len(v))
19193 }
19194 for i := range v {
19195 i := i
19196 fc := &graphql.FieldContext{
19197 Index: &i,
19198 Result: &v[i],
19199 }
19200 ctx := graphql.WithFieldContext(ctx, fc)
19201 f := func(i int) {
19202 defer func() {
19203 if r := recover(); r != nil {
19204 ec.Error(ctx, ec.Recover(ctx, r))
19205 ret = nil
19206 }
19207 }()
19208 if !isLen1 {
19209 defer wg.Done()
19210 }
19211 ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
19212 }
19213 if isLen1 {
19214 f(i)
19215 } else {
19216 go f(i)
19217 }
19218
19219 }
19220 wg.Wait()
19221
19222 return ret
19223}
19224
19225func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
19226 var res models.LabelChangeStatus
19227 err := res.UnmarshalGQL(v)
19228 return res, graphql.ErrorOnPath(ctx, err)
19229}
19230
19231func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
19232 return v
19233}
19234
19235func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
19236 return ec._LabelConnection(ctx, sel, &v)
19237}
19238
19239func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
19240 if v == nil {
19241 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19242 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19243 }
19244 return graphql.Null
19245 }
19246 return ec._LabelConnection(ctx, sel, v)
19247}
19248
19249func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
19250 ret := make(graphql.Array, len(v))
19251 var wg sync.WaitGroup
19252 isLen1 := len(v) == 1
19253 if !isLen1 {
19254 wg.Add(len(v))
19255 }
19256 for i := range v {
19257 i := i
19258 fc := &graphql.FieldContext{
19259 Index: &i,
19260 Result: &v[i],
19261 }
19262 ctx := graphql.WithFieldContext(ctx, fc)
19263 f := func(i int) {
19264 defer func() {
19265 if r := recover(); r != nil {
19266 ec.Error(ctx, ec.Recover(ctx, r))
19267 ret = nil
19268 }
19269 }()
19270 if !isLen1 {
19271 defer wg.Done()
19272 }
19273 ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
19274 }
19275 if isLen1 {
19276 f(i)
19277 } else {
19278 go f(i)
19279 }
19280
19281 }
19282 wg.Wait()
19283
19284 for _, e := range ret {
19285 if e == graphql.Null {
19286 return graphql.Null
19287 }
19288 }
19289
19290 return ret
19291}
19292
19293func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
19294 if v == nil {
19295 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19296 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19297 }
19298 return graphql.Null
19299 }
19300 return ec._LabelEdge(ctx, sel, v)
19301}
19302
19303func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
19304 res, err := ec.unmarshalInputNewBugInput(ctx, v)
19305 return res, graphql.ErrorOnPath(ctx, err)
19306}
19307
19308func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
19309 return ec._NewBugPayload(ctx, sel, &v)
19310}
19311
19312func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
19313 if v == nil {
19314 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19315 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19316 }
19317 return graphql.Null
19318 }
19319 return ec._NewBugPayload(ctx, sel, v)
19320}
19321
19322func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
19323 res, err := ec.unmarshalInputOpenBugInput(ctx, v)
19324 return res, graphql.ErrorOnPath(ctx, err)
19325}
19326
19327func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
19328 return ec._OpenBugPayload(ctx, sel, &v)
19329}
19330
19331func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
19332 if v == nil {
19333 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19334 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19335 }
19336 return graphql.Null
19337 }
19338 return ec._OpenBugPayload(ctx, sel, v)
19339}
19340
19341func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋentityᚋdagᚐOperation(ctx context.Context, sel ast.SelectionSet, v dag.Operation) graphql.Marshaler {
19342 if v == nil {
19343 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19344 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19345 }
19346 return graphql.Null
19347 }
19348 return ec._Operation(ctx, sel, v)
19349}
19350
19351func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentityᚋdagᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []dag.Operation) graphql.Marshaler {
19352 ret := make(graphql.Array, len(v))
19353 var wg sync.WaitGroup
19354 isLen1 := len(v) == 1
19355 if !isLen1 {
19356 wg.Add(len(v))
19357 }
19358 for i := range v {
19359 i := i
19360 fc := &graphql.FieldContext{
19361 Index: &i,
19362 Result: &v[i],
19363 }
19364 ctx := graphql.WithFieldContext(ctx, fc)
19365 f := func(i int) {
19366 defer func() {
19367 if r := recover(); r != nil {
19368 ec.Error(ctx, ec.Recover(ctx, r))
19369 ret = nil
19370 }
19371 }()
19372 if !isLen1 {
19373 defer wg.Done()
19374 }
19375 ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋentityᚋdagᚐOperation(ctx, sel, v[i])
19376 }
19377 if isLen1 {
19378 f(i)
19379 } else {
19380 go f(i)
19381 }
19382
19383 }
19384 wg.Wait()
19385
19386 for _, e := range ret {
19387 if e == graphql.Null {
19388 return graphql.Null
19389 }
19390 }
19391
19392 return ret
19393}
19394
19395func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
19396 return ec._OperationConnection(ctx, sel, &v)
19397}
19398
19399func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
19400 if v == nil {
19401 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19402 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19403 }
19404 return graphql.Null
19405 }
19406 return ec._OperationConnection(ctx, sel, v)
19407}
19408
19409func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
19410 ret := make(graphql.Array, len(v))
19411 var wg sync.WaitGroup
19412 isLen1 := len(v) == 1
19413 if !isLen1 {
19414 wg.Add(len(v))
19415 }
19416 for i := range v {
19417 i := i
19418 fc := &graphql.FieldContext{
19419 Index: &i,
19420 Result: &v[i],
19421 }
19422 ctx := graphql.WithFieldContext(ctx, fc)
19423 f := func(i int) {
19424 defer func() {
19425 if r := recover(); r != nil {
19426 ec.Error(ctx, ec.Recover(ctx, r))
19427 ret = nil
19428 }
19429 }()
19430 if !isLen1 {
19431 defer wg.Done()
19432 }
19433 ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
19434 }
19435 if isLen1 {
19436 f(i)
19437 } else {
19438 go f(i)
19439 }
19440
19441 }
19442 wg.Wait()
19443
19444 for _, e := range ret {
19445 if e == graphql.Null {
19446 return graphql.Null
19447 }
19448 }
19449
19450 return ret
19451}
19452
19453func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
19454 if v == nil {
19455 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19456 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19457 }
19458 return graphql.Null
19459 }
19460 return ec._OperationEdge(ctx, sel, v)
19461}
19462
19463func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
19464 if v == nil {
19465 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19466 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19467 }
19468 return graphql.Null
19469 }
19470 return ec._PageInfo(ctx, sel, v)
19471}
19472
19473func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
19474 if v == nil {
19475 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19476 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19477 }
19478 return graphql.Null
19479 }
19480 return ec._SetStatusOperation(ctx, sel, v)
19481}
19482
19483func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
19484 res, err := ec.unmarshalInputSetTitleInput(ctx, v)
19485 return res, graphql.ErrorOnPath(ctx, err)
19486}
19487
19488func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
19489 if v == nil {
19490 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19491 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19492 }
19493 return graphql.Null
19494 }
19495 return ec._SetTitleOperation(ctx, sel, v)
19496}
19497
19498func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
19499 return ec._SetTitlePayload(ctx, sel, &v)
19500}
19501
19502func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
19503 if v == nil {
19504 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19505 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19506 }
19507 return graphql.Null
19508 }
19509 return ec._SetTitlePayload(ctx, sel, v)
19510}
19511
19512func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
19513 var res models.Status
19514 err := res.UnmarshalGQL(v)
19515 return res, graphql.ErrorOnPath(ctx, err)
19516}
19517
19518func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
19519 return v
19520}
19521
19522func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
19523 res, err := graphql.UnmarshalString(v)
19524 return res, graphql.ErrorOnPath(ctx, err)
19525}
19526
19527func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
19528 res := graphql.MarshalString(v)
19529 if res == graphql.Null {
19530 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19531 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19532 }
19533 }
19534 return res
19535}
19536
19537func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
19538 res, err := graphql.UnmarshalTime(v)
19539 return res, graphql.ErrorOnPath(ctx, err)
19540}
19541
19542func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
19543 res := graphql.MarshalTime(v)
19544 if res == graphql.Null {
19545 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19546 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19547 }
19548 }
19549 return res
19550}
19551
19552func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
19553 res, err := graphql.UnmarshalTime(v)
19554 return &res, graphql.ErrorOnPath(ctx, err)
19555}
19556
19557func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
19558 if v == nil {
19559 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19560 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19561 }
19562 return graphql.Null
19563 }
19564 res := graphql.MarshalTime(*v)
19565 if res == graphql.Null {
19566 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19567 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19568 }
19569 }
19570 return res
19571}
19572
19573func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
19574 if v == nil {
19575 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19576 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19577 }
19578 return graphql.Null
19579 }
19580 return ec._TimelineItem(ctx, sel, v)
19581}
19582
19583func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
19584 ret := make(graphql.Array, len(v))
19585 var wg sync.WaitGroup
19586 isLen1 := len(v) == 1
19587 if !isLen1 {
19588 wg.Add(len(v))
19589 }
19590 for i := range v {
19591 i := i
19592 fc := &graphql.FieldContext{
19593 Index: &i,
19594 Result: &v[i],
19595 }
19596 ctx := graphql.WithFieldContext(ctx, fc)
19597 f := func(i int) {
19598 defer func() {
19599 if r := recover(); r != nil {
19600 ec.Error(ctx, ec.Recover(ctx, r))
19601 ret = nil
19602 }
19603 }()
19604 if !isLen1 {
19605 defer wg.Done()
19606 }
19607 ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
19608 }
19609 if isLen1 {
19610 f(i)
19611 } else {
19612 go f(i)
19613 }
19614
19615 }
19616 wg.Wait()
19617
19618 for _, e := range ret {
19619 if e == graphql.Null {
19620 return graphql.Null
19621 }
19622 }
19623
19624 return ret
19625}
19626
19627func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
19628 return ec._TimelineItemConnection(ctx, sel, &v)
19629}
19630
19631func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
19632 if v == nil {
19633 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19634 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19635 }
19636 return graphql.Null
19637 }
19638 return ec._TimelineItemConnection(ctx, sel, v)
19639}
19640
19641func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
19642 ret := make(graphql.Array, len(v))
19643 var wg sync.WaitGroup
19644 isLen1 := len(v) == 1
19645 if !isLen1 {
19646 wg.Add(len(v))
19647 }
19648 for i := range v {
19649 i := i
19650 fc := &graphql.FieldContext{
19651 Index: &i,
19652 Result: &v[i],
19653 }
19654 ctx := graphql.WithFieldContext(ctx, fc)
19655 f := func(i int) {
19656 defer func() {
19657 if r := recover(); r != nil {
19658 ec.Error(ctx, ec.Recover(ctx, r))
19659 ret = nil
19660 }
19661 }()
19662 if !isLen1 {
19663 defer wg.Done()
19664 }
19665 ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
19666 }
19667 if isLen1 {
19668 f(i)
19669 } else {
19670 go f(i)
19671 }
19672
19673 }
19674 wg.Wait()
19675
19676 for _, e := range ret {
19677 if e == graphql.Null {
19678 return graphql.Null
19679 }
19680 }
19681
19682 return ret
19683}
19684
19685func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
19686 if v == nil {
19687 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19688 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19689 }
19690 return graphql.Null
19691 }
19692 return ec._TimelineItemEdge(ctx, sel, v)
19693}
19694
19695func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
19696 return ec.___Directive(ctx, sel, &v)
19697}
19698
19699func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
19700 ret := make(graphql.Array, len(v))
19701 var wg sync.WaitGroup
19702 isLen1 := len(v) == 1
19703 if !isLen1 {
19704 wg.Add(len(v))
19705 }
19706 for i := range v {
19707 i := i
19708 fc := &graphql.FieldContext{
19709 Index: &i,
19710 Result: &v[i],
19711 }
19712 ctx := graphql.WithFieldContext(ctx, fc)
19713 f := func(i int) {
19714 defer func() {
19715 if r := recover(); r != nil {
19716 ec.Error(ctx, ec.Recover(ctx, r))
19717 ret = nil
19718 }
19719 }()
19720 if !isLen1 {
19721 defer wg.Done()
19722 }
19723 ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
19724 }
19725 if isLen1 {
19726 f(i)
19727 } else {
19728 go f(i)
19729 }
19730
19731 }
19732 wg.Wait()
19733
19734 for _, e := range ret {
19735 if e == graphql.Null {
19736 return graphql.Null
19737 }
19738 }
19739
19740 return ret
19741}
19742
19743func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
19744 res, err := graphql.UnmarshalString(v)
19745 return res, graphql.ErrorOnPath(ctx, err)
19746}
19747
19748func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
19749 res := graphql.MarshalString(v)
19750 if res == graphql.Null {
19751 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19752 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19753 }
19754 }
19755 return res
19756}
19757
19758func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
19759 var vSlice []interface{}
19760 if v != nil {
19761 vSlice = graphql.CoerceList(v)
19762 }
19763 var err error
19764 res := make([]string, len(vSlice))
19765 for i := range vSlice {
19766 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
19767 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
19768 if err != nil {
19769 return nil, err
19770 }
19771 }
19772 return res, nil
19773}
19774
19775func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
19776 ret := make(graphql.Array, len(v))
19777 var wg sync.WaitGroup
19778 isLen1 := len(v) == 1
19779 if !isLen1 {
19780 wg.Add(len(v))
19781 }
19782 for i := range v {
19783 i := i
19784 fc := &graphql.FieldContext{
19785 Index: &i,
19786 Result: &v[i],
19787 }
19788 ctx := graphql.WithFieldContext(ctx, fc)
19789 f := func(i int) {
19790 defer func() {
19791 if r := recover(); r != nil {
19792 ec.Error(ctx, ec.Recover(ctx, r))
19793 ret = nil
19794 }
19795 }()
19796 if !isLen1 {
19797 defer wg.Done()
19798 }
19799 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
19800 }
19801 if isLen1 {
19802 f(i)
19803 } else {
19804 go f(i)
19805 }
19806
19807 }
19808 wg.Wait()
19809
19810 for _, e := range ret {
19811 if e == graphql.Null {
19812 return graphql.Null
19813 }
19814 }
19815
19816 return ret
19817}
19818
19819func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
19820 return ec.___EnumValue(ctx, sel, &v)
19821}
19822
19823func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
19824 return ec.___Field(ctx, sel, &v)
19825}
19826
19827func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
19828 return ec.___InputValue(ctx, sel, &v)
19829}
19830
19831func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
19832 ret := make(graphql.Array, len(v))
19833 var wg sync.WaitGroup
19834 isLen1 := len(v) == 1
19835 if !isLen1 {
19836 wg.Add(len(v))
19837 }
19838 for i := range v {
19839 i := i
19840 fc := &graphql.FieldContext{
19841 Index: &i,
19842 Result: &v[i],
19843 }
19844 ctx := graphql.WithFieldContext(ctx, fc)
19845 f := func(i int) {
19846 defer func() {
19847 if r := recover(); r != nil {
19848 ec.Error(ctx, ec.Recover(ctx, r))
19849 ret = nil
19850 }
19851 }()
19852 if !isLen1 {
19853 defer wg.Done()
19854 }
19855 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
19856 }
19857 if isLen1 {
19858 f(i)
19859 } else {
19860 go f(i)
19861 }
19862
19863 }
19864 wg.Wait()
19865
19866 for _, e := range ret {
19867 if e == graphql.Null {
19868 return graphql.Null
19869 }
19870 }
19871
19872 return ret
19873}
19874
19875func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
19876 return ec.___Type(ctx, sel, &v)
19877}
19878
19879func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
19880 ret := make(graphql.Array, len(v))
19881 var wg sync.WaitGroup
19882 isLen1 := len(v) == 1
19883 if !isLen1 {
19884 wg.Add(len(v))
19885 }
19886 for i := range v {
19887 i := i
19888 fc := &graphql.FieldContext{
19889 Index: &i,
19890 Result: &v[i],
19891 }
19892 ctx := graphql.WithFieldContext(ctx, fc)
19893 f := func(i int) {
19894 defer func() {
19895 if r := recover(); r != nil {
19896 ec.Error(ctx, ec.Recover(ctx, r))
19897 ret = nil
19898 }
19899 }()
19900 if !isLen1 {
19901 defer wg.Done()
19902 }
19903 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
19904 }
19905 if isLen1 {
19906 f(i)
19907 } else {
19908 go f(i)
19909 }
19910
19911 }
19912 wg.Wait()
19913
19914 for _, e := range ret {
19915 if e == graphql.Null {
19916 return graphql.Null
19917 }
19918 }
19919
19920 return ret
19921}
19922
19923func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
19924 if v == nil {
19925 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19926 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19927 }
19928 return graphql.Null
19929 }
19930 return ec.___Type(ctx, sel, v)
19931}
19932
19933func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
19934 res, err := graphql.UnmarshalString(v)
19935 return res, graphql.ErrorOnPath(ctx, err)
19936}
19937
19938func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
19939 res := graphql.MarshalString(v)
19940 if res == graphql.Null {
19941 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
19942 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
19943 }
19944 }
19945 return res
19946}
19947
19948func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
19949 res, err := graphql.UnmarshalBoolean(v)
19950 return res, graphql.ErrorOnPath(ctx, err)
19951}
19952
19953func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
19954 res := graphql.MarshalBoolean(v)
19955 return res
19956}
19957
19958func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
19959 if v == nil {
19960 return nil, nil
19961 }
19962 res, err := graphql.UnmarshalBoolean(v)
19963 return &res, graphql.ErrorOnPath(ctx, err)
19964}
19965
19966func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
19967 if v == nil {
19968 return graphql.Null
19969 }
19970 res := graphql.MarshalBoolean(*v)
19971 return res
19972}
19973
19974func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
19975 if v == nil {
19976 return graphql.Null
19977 }
19978 return ec._Bug(ctx, sel, v)
19979}
19980
19981func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
19982 if v == nil {
19983 return nil, nil
19984 }
19985 res, err := ec.unmarshalInputChangeLabelInput(ctx, v)
19986 return &res, graphql.ErrorOnPath(ctx, err)
19987}
19988
19989func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, v interface{}) ([]repository.Hash, error) {
19990 if v == nil {
19991 return nil, nil
19992 }
19993 var vSlice []interface{}
19994 if v != nil {
19995 vSlice = graphql.CoerceList(v)
19996 }
19997 var err error
19998 res := make([]repository.Hash, len(vSlice))
19999 for i := range vSlice {
20000 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
20001 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, vSlice[i])
20002 if err != nil {
20003 return nil, err
20004 }
20005 }
20006 return res, nil
20007}
20008
20009func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []repository.Hash) graphql.Marshaler {
20010 if v == nil {
20011 return graphql.Null
20012 }
20013 ret := make(graphql.Array, len(v))
20014 for i := range v {
20015 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, sel, v[i])
20016 }
20017
20018 for _, e := range ret {
20019 if e == graphql.Null {
20020 return graphql.Null
20021 }
20022 }
20023
20024 return ret
20025}
20026
20027func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
20028 if v == nil {
20029 return graphql.Null
20030 }
20031 return ec._Identity(ctx, sel, v)
20032}
20033
20034func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
20035 if v == nil {
20036 return nil, nil
20037 }
20038 res, err := graphql.UnmarshalInt(v)
20039 return &res, graphql.ErrorOnPath(ctx, err)
20040}
20041
20042func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
20043 if v == nil {
20044 return graphql.Null
20045 }
20046 res := graphql.MarshalInt(*v)
20047 return res
20048}
20049
20050func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
20051 if v == nil {
20052 return graphql.Null
20053 }
20054 return ec._LabelChangeResult(ctx, sel, v)
20055}
20056
20057func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
20058 if v == nil {
20059 return graphql.Null
20060 }
20061 return ec._Repository(ctx, sel, v)
20062}
20063
20064func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
20065 res, err := graphql.UnmarshalString(v)
20066 return res, graphql.ErrorOnPath(ctx, err)
20067}
20068
20069func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
20070 res := graphql.MarshalString(v)
20071 return res
20072}
20073
20074func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
20075 if v == nil {
20076 return nil, nil
20077 }
20078 var vSlice []interface{}
20079 if v != nil {
20080 vSlice = graphql.CoerceList(v)
20081 }
20082 var err error
20083 res := make([]string, len(vSlice))
20084 for i := range vSlice {
20085 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
20086 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
20087 if err != nil {
20088 return nil, err
20089 }
20090 }
20091 return res, nil
20092}
20093
20094func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
20095 if v == nil {
20096 return graphql.Null
20097 }
20098 ret := make(graphql.Array, len(v))
20099 for i := range v {
20100 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
20101 }
20102
20103 for _, e := range ret {
20104 if e == graphql.Null {
20105 return graphql.Null
20106 }
20107 }
20108
20109 return ret
20110}
20111
20112func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
20113 if v == nil {
20114 return nil, nil
20115 }
20116 res, err := graphql.UnmarshalString(v)
20117 return &res, graphql.ErrorOnPath(ctx, err)
20118}
20119
20120func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
20121 if v == nil {
20122 return graphql.Null
20123 }
20124 res := graphql.MarshalString(*v)
20125 return res
20126}
20127
20128func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
20129 if v == nil {
20130 return graphql.Null
20131 }
20132 ret := make(graphql.Array, len(v))
20133 var wg sync.WaitGroup
20134 isLen1 := len(v) == 1
20135 if !isLen1 {
20136 wg.Add(len(v))
20137 }
20138 for i := range v {
20139 i := i
20140 fc := &graphql.FieldContext{
20141 Index: &i,
20142 Result: &v[i],
20143 }
20144 ctx := graphql.WithFieldContext(ctx, fc)
20145 f := func(i int) {
20146 defer func() {
20147 if r := recover(); r != nil {
20148 ec.Error(ctx, ec.Recover(ctx, r))
20149 ret = nil
20150 }
20151 }()
20152 if !isLen1 {
20153 defer wg.Done()
20154 }
20155 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
20156 }
20157 if isLen1 {
20158 f(i)
20159 } else {
20160 go f(i)
20161 }
20162
20163 }
20164 wg.Wait()
20165
20166 for _, e := range ret {
20167 if e == graphql.Null {
20168 return graphql.Null
20169 }
20170 }
20171
20172 return ret
20173}
20174
20175func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
20176 if v == nil {
20177 return graphql.Null
20178 }
20179 ret := make(graphql.Array, len(v))
20180 var wg sync.WaitGroup
20181 isLen1 := len(v) == 1
20182 if !isLen1 {
20183 wg.Add(len(v))
20184 }
20185 for i := range v {
20186 i := i
20187 fc := &graphql.FieldContext{
20188 Index: &i,
20189 Result: &v[i],
20190 }
20191 ctx := graphql.WithFieldContext(ctx, fc)
20192 f := func(i int) {
20193 defer func() {
20194 if r := recover(); r != nil {
20195 ec.Error(ctx, ec.Recover(ctx, r))
20196 ret = nil
20197 }
20198 }()
20199 if !isLen1 {
20200 defer wg.Done()
20201 }
20202 ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
20203 }
20204 if isLen1 {
20205 f(i)
20206 } else {
20207 go f(i)
20208 }
20209
20210 }
20211 wg.Wait()
20212
20213 for _, e := range ret {
20214 if e == graphql.Null {
20215 return graphql.Null
20216 }
20217 }
20218
20219 return ret
20220}
20221
20222func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
20223 if v == nil {
20224 return graphql.Null
20225 }
20226 ret := make(graphql.Array, len(v))
20227 var wg sync.WaitGroup
20228 isLen1 := len(v) == 1
20229 if !isLen1 {
20230 wg.Add(len(v))
20231 }
20232 for i := range v {
20233 i := i
20234 fc := &graphql.FieldContext{
20235 Index: &i,
20236 Result: &v[i],
20237 }
20238 ctx := graphql.WithFieldContext(ctx, fc)
20239 f := func(i int) {
20240 defer func() {
20241 if r := recover(); r != nil {
20242 ec.Error(ctx, ec.Recover(ctx, r))
20243 ret = nil
20244 }
20245 }()
20246 if !isLen1 {
20247 defer wg.Done()
20248 }
20249 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
20250 }
20251 if isLen1 {
20252 f(i)
20253 } else {
20254 go f(i)
20255 }
20256
20257 }
20258 wg.Wait()
20259
20260 for _, e := range ret {
20261 if e == graphql.Null {
20262 return graphql.Null
20263 }
20264 }
20265
20266 return ret
20267}
20268
20269func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
20270 if v == nil {
20271 return graphql.Null
20272 }
20273 return ec.___Schema(ctx, sel, v)
20274}
20275
20276func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
20277 if v == nil {
20278 return graphql.Null
20279 }
20280 ret := make(graphql.Array, len(v))
20281 var wg sync.WaitGroup
20282 isLen1 := len(v) == 1
20283 if !isLen1 {
20284 wg.Add(len(v))
20285 }
20286 for i := range v {
20287 i := i
20288 fc := &graphql.FieldContext{
20289 Index: &i,
20290 Result: &v[i],
20291 }
20292 ctx := graphql.WithFieldContext(ctx, fc)
20293 f := func(i int) {
20294 defer func() {
20295 if r := recover(); r != nil {
20296 ec.Error(ctx, ec.Recover(ctx, r))
20297 ret = nil
20298 }
20299 }()
20300 if !isLen1 {
20301 defer wg.Done()
20302 }
20303 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
20304 }
20305 if isLen1 {
20306 f(i)
20307 } else {
20308 go f(i)
20309 }
20310
20311 }
20312 wg.Wait()
20313
20314 for _, e := range ret {
20315 if e == graphql.Null {
20316 return graphql.Null
20317 }
20318 }
20319
20320 return ret
20321}
20322
20323func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
20324 if v == nil {
20325 return graphql.Null
20326 }
20327 return ec.___Type(ctx, sel, v)
20328}
20329
20330// endregion ***************************** type.gotpl *****************************