1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
2
3package graph
4
5import (
6 "bytes"
7 "context"
8 "errors"
9 "fmt"
10 "image/color"
11 "strconv"
12 "sync"
13 "sync/atomic"
14 "time"
15
16 "github.com/99designs/gqlgen/graphql"
17 "github.com/99designs/gqlgen/graphql/introspection"
18 "github.com/MichaelMure/git-bug/api/graphql/models"
19 "github.com/MichaelMure/git-bug/bug"
20 "github.com/MichaelMure/git-bug/repository"
21 gqlparser "github.com/vektah/gqlparser/v2"
22 "github.com/vektah/gqlparser/v2/ast"
23)
24
25// region ************************** generated!.gotpl **************************
26
27// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
28func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
29 return &executableSchema{
30 resolvers: cfg.Resolvers,
31 directives: cfg.Directives,
32 complexity: cfg.Complexity,
33 }
34}
35
36type Config struct {
37 Resolvers ResolverRoot
38 Directives DirectiveRoot
39 Complexity ComplexityRoot
40}
41
42type ResolverRoot interface {
43 AddCommentOperation() AddCommentOperationResolver
44 AddCommentTimelineItem() AddCommentTimelineItemResolver
45 Bug() BugResolver
46 Color() ColorResolver
47 Comment() CommentResolver
48 CommentHistoryStep() CommentHistoryStepResolver
49 CreateOperation() CreateOperationResolver
50 CreateTimelineItem() CreateTimelineItemResolver
51 EditCommentOperation() EditCommentOperationResolver
52 Identity() IdentityResolver
53 Label() LabelResolver
54 LabelChangeOperation() LabelChangeOperationResolver
55 LabelChangeResult() LabelChangeResultResolver
56 LabelChangeTimelineItem() LabelChangeTimelineItemResolver
57 Mutation() MutationResolver
58 Query() QueryResolver
59 Repository() RepositoryResolver
60 SetStatusOperation() SetStatusOperationResolver
61 SetStatusTimelineItem() SetStatusTimelineItemResolver
62 SetTitleOperation() SetTitleOperationResolver
63 SetTitleTimelineItem() SetTitleTimelineItemResolver
64}
65
66type DirectiveRoot struct {
67}
68
69type ComplexityRoot struct {
70 AddCommentAndCloseBugPayload struct {
71 Bug func(childComplexity int) int
72 ClientMutationID func(childComplexity int) int
73 CommentOperation func(childComplexity int) int
74 StatusOperation func(childComplexity int) int
75 }
76
77 AddCommentAndReopenBugPayload struct {
78 Bug func(childComplexity int) int
79 ClientMutationID func(childComplexity int) int
80 CommentOperation func(childComplexity int) int
81 StatusOperation func(childComplexity int) int
82 }
83
84 AddCommentOperation struct {
85 Author func(childComplexity int) int
86 Date func(childComplexity int) int
87 Files func(childComplexity int) int
88 ID func(childComplexity int) int
89 Message func(childComplexity int) int
90 }
91
92 AddCommentPayload struct {
93 Bug func(childComplexity int) int
94 ClientMutationID func(childComplexity int) int
95 Operation func(childComplexity int) int
96 }
97
98 AddCommentTimelineItem struct {
99 Author func(childComplexity int) int
100 CreatedAt func(childComplexity int) int
101 Edited func(childComplexity int) int
102 Files func(childComplexity int) int
103 History func(childComplexity int) int
104 ID func(childComplexity int) int
105 LastEdit func(childComplexity int) int
106 Message func(childComplexity int) int
107 MessageIsEmpty func(childComplexity int) int
108 }
109
110 Bug struct {
111 Actors func(childComplexity int, after *string, before *string, first *int, last *int) int
112 Author func(childComplexity int) int
113 Comments func(childComplexity int, after *string, before *string, first *int, last *int) int
114 CreatedAt func(childComplexity int) int
115 HumanID func(childComplexity int) int
116 ID func(childComplexity int) int
117 Labels func(childComplexity int) int
118 LastEdit func(childComplexity int) int
119 Operations func(childComplexity int, after *string, before *string, first *int, last *int) int
120 Participants func(childComplexity int, after *string, before *string, first *int, last *int) int
121 Status func(childComplexity int) int
122 Timeline func(childComplexity int, after *string, before *string, first *int, last *int) int
123 Title func(childComplexity int) int
124 }
125
126 BugConnection struct {
127 Edges func(childComplexity int) int
128 Nodes func(childComplexity int) int
129 PageInfo func(childComplexity int) int
130 TotalCount func(childComplexity int) int
131 }
132
133 BugEdge struct {
134 Cursor func(childComplexity int) int
135 Node func(childComplexity int) int
136 }
137
138 ChangeLabelPayload struct {
139 Bug func(childComplexity int) int
140 ClientMutationID func(childComplexity int) int
141 Operation func(childComplexity int) int
142 Results func(childComplexity int) int
143 }
144
145 CloseBugPayload struct {
146 Bug func(childComplexity int) int
147 ClientMutationID func(childComplexity int) int
148 Operation func(childComplexity int) int
149 }
150
151 Color struct {
152 B func(childComplexity int) int
153 G func(childComplexity int) int
154 R func(childComplexity int) int
155 }
156
157 Comment struct {
158 Author func(childComplexity int) int
159 Files func(childComplexity int) int
160 Message func(childComplexity int) int
161 }
162
163 CommentConnection struct {
164 Edges func(childComplexity int) int
165 Nodes func(childComplexity int) int
166 PageInfo func(childComplexity int) int
167 TotalCount func(childComplexity int) int
168 }
169
170 CommentEdge struct {
171 Cursor func(childComplexity int) int
172 Node func(childComplexity int) int
173 }
174
175 CommentHistoryStep struct {
176 Date func(childComplexity int) int
177 Message func(childComplexity int) int
178 }
179
180 CreateOperation struct {
181 Author func(childComplexity int) int
182 Date func(childComplexity int) int
183 Files func(childComplexity int) int
184 ID func(childComplexity int) int
185 Message func(childComplexity int) int
186 Title func(childComplexity int) int
187 }
188
189 CreateTimelineItem struct {
190 Author func(childComplexity int) int
191 CreatedAt func(childComplexity int) int
192 Edited func(childComplexity int) int
193 Files func(childComplexity int) int
194 History func(childComplexity int) int
195 ID func(childComplexity int) int
196 LastEdit func(childComplexity int) int
197 Message func(childComplexity int) int
198 MessageIsEmpty func(childComplexity int) int
199 }
200
201 EditCommentOperation struct {
202 Author func(childComplexity int) int
203 Date func(childComplexity int) int
204 Files func(childComplexity int) int
205 ID func(childComplexity int) int
206 Message func(childComplexity int) int
207 Target func(childComplexity int) int
208 }
209
210 EditCommentPayload struct {
211 Bug func(childComplexity int) int
212 ClientMutationID func(childComplexity int) int
213 Operation func(childComplexity int) int
214 }
215
216 Identity struct {
217 AvatarUrl func(childComplexity int) int
218 DisplayName func(childComplexity int) int
219 Email func(childComplexity int) int
220 HumanID func(childComplexity int) int
221 ID func(childComplexity int) int
222 IsProtected func(childComplexity int) int
223 Login func(childComplexity int) int
224 Name func(childComplexity int) int
225 }
226
227 IdentityConnection struct {
228 Edges func(childComplexity int) int
229 Nodes func(childComplexity int) int
230 PageInfo func(childComplexity int) int
231 TotalCount func(childComplexity int) int
232 }
233
234 IdentityEdge struct {
235 Cursor func(childComplexity int) int
236 Node func(childComplexity int) int
237 }
238
239 Label struct {
240 Color func(childComplexity int) int
241 Name func(childComplexity int) int
242 }
243
244 LabelChangeOperation struct {
245 Added func(childComplexity int) int
246 Author func(childComplexity int) int
247 Date func(childComplexity int) int
248 ID func(childComplexity int) int
249 Removed func(childComplexity int) int
250 }
251
252 LabelChangeResult struct {
253 Label func(childComplexity int) int
254 Status func(childComplexity int) int
255 }
256
257 LabelChangeTimelineItem struct {
258 Added func(childComplexity int) int
259 Author func(childComplexity int) int
260 Date func(childComplexity int) int
261 ID func(childComplexity int) int
262 Removed func(childComplexity int) int
263 }
264
265 LabelConnection struct {
266 Edges func(childComplexity int) int
267 Nodes func(childComplexity int) int
268 PageInfo func(childComplexity int) int
269 TotalCount func(childComplexity int) int
270 }
271
272 LabelEdge struct {
273 Cursor func(childComplexity int) int
274 Node func(childComplexity int) int
275 }
276
277 Mutation struct {
278 AddComment func(childComplexity int, input models.AddCommentInput) int
279 AddCommentAndClose func(childComplexity int, input models.AddCommentAndCloseBugInput) int
280 AddCommentAndReopen func(childComplexity int, input models.AddCommentAndReopenBugInput) int
281 ChangeLabels func(childComplexity int, input *models.ChangeLabelInput) int
282 CloseBug func(childComplexity int, input models.CloseBugInput) int
283 EditComment func(childComplexity int, input models.EditCommentInput) int
284 NewBug func(childComplexity int, input models.NewBugInput) int
285 OpenBug func(childComplexity int, input models.OpenBugInput) int
286 SetTitle func(childComplexity int, input models.SetTitleInput) int
287 }
288
289 NewBugPayload struct {
290 Bug func(childComplexity int) int
291 ClientMutationID func(childComplexity int) int
292 Operation func(childComplexity int) int
293 }
294
295 OpenBugPayload struct {
296 Bug func(childComplexity int) int
297 ClientMutationID func(childComplexity int) int
298 Operation func(childComplexity int) int
299 }
300
301 OperationConnection struct {
302 Edges func(childComplexity int) int
303 Nodes func(childComplexity int) int
304 PageInfo func(childComplexity int) int
305 TotalCount func(childComplexity int) int
306 }
307
308 OperationEdge struct {
309 Cursor func(childComplexity int) int
310 Node func(childComplexity int) int
311 }
312
313 PageInfo struct {
314 EndCursor func(childComplexity int) int
315 HasNextPage func(childComplexity int) int
316 HasPreviousPage func(childComplexity int) int
317 StartCursor func(childComplexity int) int
318 }
319
320 Query struct {
321 Repository func(childComplexity int, ref *string) int
322 }
323
324 Repository struct {
325 AllBugs func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
326 AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
327 Bug func(childComplexity int, prefix string) int
328 Identity func(childComplexity int, prefix string) int
329 Name func(childComplexity int) int
330 UserIdentity func(childComplexity int) int
331 ValidLabels func(childComplexity int, after *string, before *string, first *int, last *int) int
332 }
333
334 SetStatusOperation struct {
335 Author func(childComplexity int) int
336 Date func(childComplexity int) int
337 ID func(childComplexity int) int
338 Status func(childComplexity int) int
339 }
340
341 SetStatusTimelineItem struct {
342 Author func(childComplexity int) int
343 Date func(childComplexity int) int
344 ID func(childComplexity int) int
345 Status func(childComplexity int) int
346 }
347
348 SetTitleOperation struct {
349 Author func(childComplexity int) int
350 Date func(childComplexity int) int
351 ID func(childComplexity int) int
352 Title func(childComplexity int) int
353 Was func(childComplexity int) int
354 }
355
356 SetTitlePayload struct {
357 Bug func(childComplexity int) int
358 ClientMutationID func(childComplexity int) int
359 Operation func(childComplexity int) int
360 }
361
362 SetTitleTimelineItem struct {
363 Author func(childComplexity int) int
364 Date func(childComplexity int) int
365 ID func(childComplexity int) int
366 Title func(childComplexity int) int
367 Was func(childComplexity int) int
368 }
369
370 TimelineItemConnection struct {
371 Edges func(childComplexity int) int
372 Nodes func(childComplexity int) int
373 PageInfo func(childComplexity int) int
374 TotalCount func(childComplexity int) int
375 }
376
377 TimelineItemEdge struct {
378 Cursor func(childComplexity int) int
379 Node func(childComplexity int) int
380 }
381}
382
383type AddCommentOperationResolver interface {
384 ID(ctx context.Context, obj *bug.AddCommentOperation) (string, error)
385 Author(ctx context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error)
386 Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
387}
388type AddCommentTimelineItemResolver interface {
389 ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (string, error)
390 Author(ctx context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, error)
391
392 CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
393 LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
394}
395type BugResolver interface {
396 ID(ctx context.Context, obj models.BugWrapper) (string, error)
397 HumanID(ctx context.Context, obj models.BugWrapper) (string, error)
398 Status(ctx context.Context, obj models.BugWrapper) (models.Status, error)
399
400 Actors(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
401 Participants(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
402 Comments(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
403 Timeline(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
404 Operations(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
405}
406type ColorResolver interface {
407 R(ctx context.Context, obj *color.RGBA) (int, error)
408 G(ctx context.Context, obj *color.RGBA) (int, error)
409 B(ctx context.Context, obj *color.RGBA) (int, error)
410}
411type CommentResolver interface {
412 Author(ctx context.Context, obj *bug.Comment) (models.IdentityWrapper, error)
413}
414type CommentHistoryStepResolver interface {
415 Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
416}
417type CreateOperationResolver interface {
418 ID(ctx context.Context, obj *bug.CreateOperation) (string, error)
419 Author(ctx context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error)
420 Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
421}
422type CreateTimelineItemResolver interface {
423 ID(ctx context.Context, obj *bug.CreateTimelineItem) (string, error)
424 Author(ctx context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error)
425
426 CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
427 LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
428}
429type EditCommentOperationResolver interface {
430 ID(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
431 Author(ctx context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error)
432 Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
433 Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
434}
435type IdentityResolver interface {
436 ID(ctx context.Context, obj models.IdentityWrapper) (string, error)
437 HumanID(ctx context.Context, obj models.IdentityWrapper) (string, error)
438}
439type LabelResolver interface {
440 Name(ctx context.Context, obj *bug.Label) (string, error)
441 Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
442}
443type LabelChangeOperationResolver interface {
444 ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
445 Author(ctx context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error)
446 Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
447}
448type LabelChangeResultResolver interface {
449 Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
450}
451type LabelChangeTimelineItemResolver interface {
452 ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
453 Author(ctx context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error)
454 Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
455}
456type MutationResolver interface {
457 NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
458 AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
459 AddCommentAndClose(ctx context.Context, input models.AddCommentAndCloseBugInput) (*models.AddCommentAndCloseBugPayload, error)
460 AddCommentAndReopen(ctx context.Context, input models.AddCommentAndReopenBugInput) (*models.AddCommentAndReopenBugPayload, error)
461 EditComment(ctx context.Context, input models.EditCommentInput) (*models.EditCommentPayload, error)
462 ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
463 OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
464 CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
465 SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
466}
467type QueryResolver interface {
468 Repository(ctx context.Context, ref *string) (*models.Repository, error)
469}
470type RepositoryResolver interface {
471 Name(ctx context.Context, obj *models.Repository) (*string, error)
472 AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
473 Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
474 AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
475 Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
476 UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
477 ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
478}
479type SetStatusOperationResolver interface {
480 ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
481 Author(ctx context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error)
482 Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
483 Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
484}
485type SetStatusTimelineItemResolver interface {
486 ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
487 Author(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error)
488 Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
489 Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
490}
491type SetTitleOperationResolver interface {
492 ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
493 Author(ctx context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error)
494 Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
495}
496type SetTitleTimelineItemResolver interface {
497 ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
498 Author(ctx context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error)
499 Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
500}
501
502type executableSchema struct {
503 resolvers ResolverRoot
504 directives DirectiveRoot
505 complexity ComplexityRoot
506}
507
508func (e *executableSchema) Schema() *ast.Schema {
509 return parsedSchema
510}
511
512func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
513 ec := executionContext{nil, e}
514 _ = ec
515 switch typeName + "." + field {
516
517 case "AddCommentAndCloseBugPayload.bug":
518 if e.complexity.AddCommentAndCloseBugPayload.Bug == nil {
519 break
520 }
521
522 return e.complexity.AddCommentAndCloseBugPayload.Bug(childComplexity), true
523
524 case "AddCommentAndCloseBugPayload.clientMutationId":
525 if e.complexity.AddCommentAndCloseBugPayload.ClientMutationID == nil {
526 break
527 }
528
529 return e.complexity.AddCommentAndCloseBugPayload.ClientMutationID(childComplexity), true
530
531 case "AddCommentAndCloseBugPayload.commentOperation":
532 if e.complexity.AddCommentAndCloseBugPayload.CommentOperation == nil {
533 break
534 }
535
536 return e.complexity.AddCommentAndCloseBugPayload.CommentOperation(childComplexity), true
537
538 case "AddCommentAndCloseBugPayload.statusOperation":
539 if e.complexity.AddCommentAndCloseBugPayload.StatusOperation == nil {
540 break
541 }
542
543 return e.complexity.AddCommentAndCloseBugPayload.StatusOperation(childComplexity), true
544
545 case "AddCommentAndReopenBugPayload.bug":
546 if e.complexity.AddCommentAndReopenBugPayload.Bug == nil {
547 break
548 }
549
550 return e.complexity.AddCommentAndReopenBugPayload.Bug(childComplexity), true
551
552 case "AddCommentAndReopenBugPayload.clientMutationId":
553 if e.complexity.AddCommentAndReopenBugPayload.ClientMutationID == nil {
554 break
555 }
556
557 return e.complexity.AddCommentAndReopenBugPayload.ClientMutationID(childComplexity), true
558
559 case "AddCommentAndReopenBugPayload.commentOperation":
560 if e.complexity.AddCommentAndReopenBugPayload.CommentOperation == nil {
561 break
562 }
563
564 return e.complexity.AddCommentAndReopenBugPayload.CommentOperation(childComplexity), true
565
566 case "AddCommentAndReopenBugPayload.statusOperation":
567 if e.complexity.AddCommentAndReopenBugPayload.StatusOperation == nil {
568 break
569 }
570
571 return e.complexity.AddCommentAndReopenBugPayload.StatusOperation(childComplexity), true
572
573 case "AddCommentOperation.author":
574 if e.complexity.AddCommentOperation.Author == nil {
575 break
576 }
577
578 return e.complexity.AddCommentOperation.Author(childComplexity), true
579
580 case "AddCommentOperation.date":
581 if e.complexity.AddCommentOperation.Date == nil {
582 break
583 }
584
585 return e.complexity.AddCommentOperation.Date(childComplexity), true
586
587 case "AddCommentOperation.files":
588 if e.complexity.AddCommentOperation.Files == nil {
589 break
590 }
591
592 return e.complexity.AddCommentOperation.Files(childComplexity), true
593
594 case "AddCommentOperation.id":
595 if e.complexity.AddCommentOperation.ID == nil {
596 break
597 }
598
599 return e.complexity.AddCommentOperation.ID(childComplexity), true
600
601 case "AddCommentOperation.message":
602 if e.complexity.AddCommentOperation.Message == nil {
603 break
604 }
605
606 return e.complexity.AddCommentOperation.Message(childComplexity), true
607
608 case "AddCommentPayload.bug":
609 if e.complexity.AddCommentPayload.Bug == nil {
610 break
611 }
612
613 return e.complexity.AddCommentPayload.Bug(childComplexity), true
614
615 case "AddCommentPayload.clientMutationId":
616 if e.complexity.AddCommentPayload.ClientMutationID == nil {
617 break
618 }
619
620 return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
621
622 case "AddCommentPayload.operation":
623 if e.complexity.AddCommentPayload.Operation == nil {
624 break
625 }
626
627 return e.complexity.AddCommentPayload.Operation(childComplexity), true
628
629 case "AddCommentTimelineItem.author":
630 if e.complexity.AddCommentTimelineItem.Author == nil {
631 break
632 }
633
634 return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
635
636 case "AddCommentTimelineItem.createdAt":
637 if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
638 break
639 }
640
641 return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
642
643 case "AddCommentTimelineItem.edited":
644 if e.complexity.AddCommentTimelineItem.Edited == nil {
645 break
646 }
647
648 return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
649
650 case "AddCommentTimelineItem.files":
651 if e.complexity.AddCommentTimelineItem.Files == nil {
652 break
653 }
654
655 return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
656
657 case "AddCommentTimelineItem.history":
658 if e.complexity.AddCommentTimelineItem.History == nil {
659 break
660 }
661
662 return e.complexity.AddCommentTimelineItem.History(childComplexity), true
663
664 case "AddCommentTimelineItem.id":
665 if e.complexity.AddCommentTimelineItem.ID == nil {
666 break
667 }
668
669 return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
670
671 case "AddCommentTimelineItem.lastEdit":
672 if e.complexity.AddCommentTimelineItem.LastEdit == nil {
673 break
674 }
675
676 return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
677
678 case "AddCommentTimelineItem.message":
679 if e.complexity.AddCommentTimelineItem.Message == nil {
680 break
681 }
682
683 return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
684
685 case "AddCommentTimelineItem.messageIsEmpty":
686 if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
687 break
688 }
689
690 return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
691
692 case "Bug.actors":
693 if e.complexity.Bug.Actors == nil {
694 break
695 }
696
697 args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
698 if err != nil {
699 return 0, false
700 }
701
702 return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
703
704 case "Bug.author":
705 if e.complexity.Bug.Author == nil {
706 break
707 }
708
709 return e.complexity.Bug.Author(childComplexity), true
710
711 case "Bug.comments":
712 if e.complexity.Bug.Comments == nil {
713 break
714 }
715
716 args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
717 if err != nil {
718 return 0, false
719 }
720
721 return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
722
723 case "Bug.createdAt":
724 if e.complexity.Bug.CreatedAt == nil {
725 break
726 }
727
728 return e.complexity.Bug.CreatedAt(childComplexity), true
729
730 case "Bug.humanId":
731 if e.complexity.Bug.HumanID == nil {
732 break
733 }
734
735 return e.complexity.Bug.HumanID(childComplexity), true
736
737 case "Bug.id":
738 if e.complexity.Bug.ID == nil {
739 break
740 }
741
742 return e.complexity.Bug.ID(childComplexity), true
743
744 case "Bug.labels":
745 if e.complexity.Bug.Labels == nil {
746 break
747 }
748
749 return e.complexity.Bug.Labels(childComplexity), true
750
751 case "Bug.lastEdit":
752 if e.complexity.Bug.LastEdit == nil {
753 break
754 }
755
756 return e.complexity.Bug.LastEdit(childComplexity), true
757
758 case "Bug.operations":
759 if e.complexity.Bug.Operations == nil {
760 break
761 }
762
763 args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
764 if err != nil {
765 return 0, false
766 }
767
768 return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
769
770 case "Bug.participants":
771 if e.complexity.Bug.Participants == nil {
772 break
773 }
774
775 args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
776 if err != nil {
777 return 0, false
778 }
779
780 return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
781
782 case "Bug.status":
783 if e.complexity.Bug.Status == nil {
784 break
785 }
786
787 return e.complexity.Bug.Status(childComplexity), true
788
789 case "Bug.timeline":
790 if e.complexity.Bug.Timeline == nil {
791 break
792 }
793
794 args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
795 if err != nil {
796 return 0, false
797 }
798
799 return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
800
801 case "Bug.title":
802 if e.complexity.Bug.Title == nil {
803 break
804 }
805
806 return e.complexity.Bug.Title(childComplexity), true
807
808 case "BugConnection.edges":
809 if e.complexity.BugConnection.Edges == nil {
810 break
811 }
812
813 return e.complexity.BugConnection.Edges(childComplexity), true
814
815 case "BugConnection.nodes":
816 if e.complexity.BugConnection.Nodes == nil {
817 break
818 }
819
820 return e.complexity.BugConnection.Nodes(childComplexity), true
821
822 case "BugConnection.pageInfo":
823 if e.complexity.BugConnection.PageInfo == nil {
824 break
825 }
826
827 return e.complexity.BugConnection.PageInfo(childComplexity), true
828
829 case "BugConnection.totalCount":
830 if e.complexity.BugConnection.TotalCount == nil {
831 break
832 }
833
834 return e.complexity.BugConnection.TotalCount(childComplexity), true
835
836 case "BugEdge.cursor":
837 if e.complexity.BugEdge.Cursor == nil {
838 break
839 }
840
841 return e.complexity.BugEdge.Cursor(childComplexity), true
842
843 case "BugEdge.node":
844 if e.complexity.BugEdge.Node == nil {
845 break
846 }
847
848 return e.complexity.BugEdge.Node(childComplexity), true
849
850 case "ChangeLabelPayload.bug":
851 if e.complexity.ChangeLabelPayload.Bug == nil {
852 break
853 }
854
855 return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
856
857 case "ChangeLabelPayload.clientMutationId":
858 if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
859 break
860 }
861
862 return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
863
864 case "ChangeLabelPayload.operation":
865 if e.complexity.ChangeLabelPayload.Operation == nil {
866 break
867 }
868
869 return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
870
871 case "ChangeLabelPayload.results":
872 if e.complexity.ChangeLabelPayload.Results == nil {
873 break
874 }
875
876 return e.complexity.ChangeLabelPayload.Results(childComplexity), true
877
878 case "CloseBugPayload.bug":
879 if e.complexity.CloseBugPayload.Bug == nil {
880 break
881 }
882
883 return e.complexity.CloseBugPayload.Bug(childComplexity), true
884
885 case "CloseBugPayload.clientMutationId":
886 if e.complexity.CloseBugPayload.ClientMutationID == nil {
887 break
888 }
889
890 return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
891
892 case "CloseBugPayload.operation":
893 if e.complexity.CloseBugPayload.Operation == nil {
894 break
895 }
896
897 return e.complexity.CloseBugPayload.Operation(childComplexity), true
898
899 case "Color.B":
900 if e.complexity.Color.B == nil {
901 break
902 }
903
904 return e.complexity.Color.B(childComplexity), true
905
906 case "Color.G":
907 if e.complexity.Color.G == nil {
908 break
909 }
910
911 return e.complexity.Color.G(childComplexity), true
912
913 case "Color.R":
914 if e.complexity.Color.R == nil {
915 break
916 }
917
918 return e.complexity.Color.R(childComplexity), true
919
920 case "Comment.author":
921 if e.complexity.Comment.Author == nil {
922 break
923 }
924
925 return e.complexity.Comment.Author(childComplexity), true
926
927 case "Comment.files":
928 if e.complexity.Comment.Files == nil {
929 break
930 }
931
932 return e.complexity.Comment.Files(childComplexity), true
933
934 case "Comment.message":
935 if e.complexity.Comment.Message == nil {
936 break
937 }
938
939 return e.complexity.Comment.Message(childComplexity), true
940
941 case "CommentConnection.edges":
942 if e.complexity.CommentConnection.Edges == nil {
943 break
944 }
945
946 return e.complexity.CommentConnection.Edges(childComplexity), true
947
948 case "CommentConnection.nodes":
949 if e.complexity.CommentConnection.Nodes == nil {
950 break
951 }
952
953 return e.complexity.CommentConnection.Nodes(childComplexity), true
954
955 case "CommentConnection.pageInfo":
956 if e.complexity.CommentConnection.PageInfo == nil {
957 break
958 }
959
960 return e.complexity.CommentConnection.PageInfo(childComplexity), true
961
962 case "CommentConnection.totalCount":
963 if e.complexity.CommentConnection.TotalCount == nil {
964 break
965 }
966
967 return e.complexity.CommentConnection.TotalCount(childComplexity), true
968
969 case "CommentEdge.cursor":
970 if e.complexity.CommentEdge.Cursor == nil {
971 break
972 }
973
974 return e.complexity.CommentEdge.Cursor(childComplexity), true
975
976 case "CommentEdge.node":
977 if e.complexity.CommentEdge.Node == nil {
978 break
979 }
980
981 return e.complexity.CommentEdge.Node(childComplexity), true
982
983 case "CommentHistoryStep.date":
984 if e.complexity.CommentHistoryStep.Date == nil {
985 break
986 }
987
988 return e.complexity.CommentHistoryStep.Date(childComplexity), true
989
990 case "CommentHistoryStep.message":
991 if e.complexity.CommentHistoryStep.Message == nil {
992 break
993 }
994
995 return e.complexity.CommentHistoryStep.Message(childComplexity), true
996
997 case "CreateOperation.author":
998 if e.complexity.CreateOperation.Author == nil {
999 break
1000 }
1001
1002 return e.complexity.CreateOperation.Author(childComplexity), true
1003
1004 case "CreateOperation.date":
1005 if e.complexity.CreateOperation.Date == nil {
1006 break
1007 }
1008
1009 return e.complexity.CreateOperation.Date(childComplexity), true
1010
1011 case "CreateOperation.files":
1012 if e.complexity.CreateOperation.Files == nil {
1013 break
1014 }
1015
1016 return e.complexity.CreateOperation.Files(childComplexity), true
1017
1018 case "CreateOperation.id":
1019 if e.complexity.CreateOperation.ID == nil {
1020 break
1021 }
1022
1023 return e.complexity.CreateOperation.ID(childComplexity), true
1024
1025 case "CreateOperation.message":
1026 if e.complexity.CreateOperation.Message == nil {
1027 break
1028 }
1029
1030 return e.complexity.CreateOperation.Message(childComplexity), true
1031
1032 case "CreateOperation.title":
1033 if e.complexity.CreateOperation.Title == nil {
1034 break
1035 }
1036
1037 return e.complexity.CreateOperation.Title(childComplexity), true
1038
1039 case "CreateTimelineItem.author":
1040 if e.complexity.CreateTimelineItem.Author == nil {
1041 break
1042 }
1043
1044 return e.complexity.CreateTimelineItem.Author(childComplexity), true
1045
1046 case "CreateTimelineItem.createdAt":
1047 if e.complexity.CreateTimelineItem.CreatedAt == nil {
1048 break
1049 }
1050
1051 return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
1052
1053 case "CreateTimelineItem.edited":
1054 if e.complexity.CreateTimelineItem.Edited == nil {
1055 break
1056 }
1057
1058 return e.complexity.CreateTimelineItem.Edited(childComplexity), true
1059
1060 case "CreateTimelineItem.files":
1061 if e.complexity.CreateTimelineItem.Files == nil {
1062 break
1063 }
1064
1065 return e.complexity.CreateTimelineItem.Files(childComplexity), true
1066
1067 case "CreateTimelineItem.history":
1068 if e.complexity.CreateTimelineItem.History == nil {
1069 break
1070 }
1071
1072 return e.complexity.CreateTimelineItem.History(childComplexity), true
1073
1074 case "CreateTimelineItem.id":
1075 if e.complexity.CreateTimelineItem.ID == nil {
1076 break
1077 }
1078
1079 return e.complexity.CreateTimelineItem.ID(childComplexity), true
1080
1081 case "CreateTimelineItem.lastEdit":
1082 if e.complexity.CreateTimelineItem.LastEdit == nil {
1083 break
1084 }
1085
1086 return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
1087
1088 case "CreateTimelineItem.message":
1089 if e.complexity.CreateTimelineItem.Message == nil {
1090 break
1091 }
1092
1093 return e.complexity.CreateTimelineItem.Message(childComplexity), true
1094
1095 case "CreateTimelineItem.messageIsEmpty":
1096 if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
1097 break
1098 }
1099
1100 return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
1101
1102 case "EditCommentOperation.author":
1103 if e.complexity.EditCommentOperation.Author == nil {
1104 break
1105 }
1106
1107 return e.complexity.EditCommentOperation.Author(childComplexity), true
1108
1109 case "EditCommentOperation.date":
1110 if e.complexity.EditCommentOperation.Date == nil {
1111 break
1112 }
1113
1114 return e.complexity.EditCommentOperation.Date(childComplexity), true
1115
1116 case "EditCommentOperation.files":
1117 if e.complexity.EditCommentOperation.Files == nil {
1118 break
1119 }
1120
1121 return e.complexity.EditCommentOperation.Files(childComplexity), true
1122
1123 case "EditCommentOperation.id":
1124 if e.complexity.EditCommentOperation.ID == nil {
1125 break
1126 }
1127
1128 return e.complexity.EditCommentOperation.ID(childComplexity), true
1129
1130 case "EditCommentOperation.message":
1131 if e.complexity.EditCommentOperation.Message == nil {
1132 break
1133 }
1134
1135 return e.complexity.EditCommentOperation.Message(childComplexity), true
1136
1137 case "EditCommentOperation.target":
1138 if e.complexity.EditCommentOperation.Target == nil {
1139 break
1140 }
1141
1142 return e.complexity.EditCommentOperation.Target(childComplexity), true
1143
1144 case "EditCommentPayload.bug":
1145 if e.complexity.EditCommentPayload.Bug == nil {
1146 break
1147 }
1148
1149 return e.complexity.EditCommentPayload.Bug(childComplexity), true
1150
1151 case "EditCommentPayload.clientMutationId":
1152 if e.complexity.EditCommentPayload.ClientMutationID == nil {
1153 break
1154 }
1155
1156 return e.complexity.EditCommentPayload.ClientMutationID(childComplexity), true
1157
1158 case "EditCommentPayload.operation":
1159 if e.complexity.EditCommentPayload.Operation == nil {
1160 break
1161 }
1162
1163 return e.complexity.EditCommentPayload.Operation(childComplexity), true
1164
1165 case "Identity.avatarUrl":
1166 if e.complexity.Identity.AvatarUrl == nil {
1167 break
1168 }
1169
1170 return e.complexity.Identity.AvatarUrl(childComplexity), true
1171
1172 case "Identity.displayName":
1173 if e.complexity.Identity.DisplayName == nil {
1174 break
1175 }
1176
1177 return e.complexity.Identity.DisplayName(childComplexity), true
1178
1179 case "Identity.email":
1180 if e.complexity.Identity.Email == nil {
1181 break
1182 }
1183
1184 return e.complexity.Identity.Email(childComplexity), true
1185
1186 case "Identity.humanId":
1187 if e.complexity.Identity.HumanID == nil {
1188 break
1189 }
1190
1191 return e.complexity.Identity.HumanID(childComplexity), true
1192
1193 case "Identity.id":
1194 if e.complexity.Identity.ID == nil {
1195 break
1196 }
1197
1198 return e.complexity.Identity.ID(childComplexity), true
1199
1200 case "Identity.isProtected":
1201 if e.complexity.Identity.IsProtected == nil {
1202 break
1203 }
1204
1205 return e.complexity.Identity.IsProtected(childComplexity), true
1206
1207 case "Identity.login":
1208 if e.complexity.Identity.Login == nil {
1209 break
1210 }
1211
1212 return e.complexity.Identity.Login(childComplexity), true
1213
1214 case "Identity.name":
1215 if e.complexity.Identity.Name == nil {
1216 break
1217 }
1218
1219 return e.complexity.Identity.Name(childComplexity), true
1220
1221 case "IdentityConnection.edges":
1222 if e.complexity.IdentityConnection.Edges == nil {
1223 break
1224 }
1225
1226 return e.complexity.IdentityConnection.Edges(childComplexity), true
1227
1228 case "IdentityConnection.nodes":
1229 if e.complexity.IdentityConnection.Nodes == nil {
1230 break
1231 }
1232
1233 return e.complexity.IdentityConnection.Nodes(childComplexity), true
1234
1235 case "IdentityConnection.pageInfo":
1236 if e.complexity.IdentityConnection.PageInfo == nil {
1237 break
1238 }
1239
1240 return e.complexity.IdentityConnection.PageInfo(childComplexity), true
1241
1242 case "IdentityConnection.totalCount":
1243 if e.complexity.IdentityConnection.TotalCount == nil {
1244 break
1245 }
1246
1247 return e.complexity.IdentityConnection.TotalCount(childComplexity), true
1248
1249 case "IdentityEdge.cursor":
1250 if e.complexity.IdentityEdge.Cursor == nil {
1251 break
1252 }
1253
1254 return e.complexity.IdentityEdge.Cursor(childComplexity), true
1255
1256 case "IdentityEdge.node":
1257 if e.complexity.IdentityEdge.Node == nil {
1258 break
1259 }
1260
1261 return e.complexity.IdentityEdge.Node(childComplexity), true
1262
1263 case "Label.color":
1264 if e.complexity.Label.Color == nil {
1265 break
1266 }
1267
1268 return e.complexity.Label.Color(childComplexity), true
1269
1270 case "Label.name":
1271 if e.complexity.Label.Name == nil {
1272 break
1273 }
1274
1275 return e.complexity.Label.Name(childComplexity), true
1276
1277 case "LabelChangeOperation.added":
1278 if e.complexity.LabelChangeOperation.Added == nil {
1279 break
1280 }
1281
1282 return e.complexity.LabelChangeOperation.Added(childComplexity), true
1283
1284 case "LabelChangeOperation.author":
1285 if e.complexity.LabelChangeOperation.Author == nil {
1286 break
1287 }
1288
1289 return e.complexity.LabelChangeOperation.Author(childComplexity), true
1290
1291 case "LabelChangeOperation.date":
1292 if e.complexity.LabelChangeOperation.Date == nil {
1293 break
1294 }
1295
1296 return e.complexity.LabelChangeOperation.Date(childComplexity), true
1297
1298 case "LabelChangeOperation.id":
1299 if e.complexity.LabelChangeOperation.ID == nil {
1300 break
1301 }
1302
1303 return e.complexity.LabelChangeOperation.ID(childComplexity), true
1304
1305 case "LabelChangeOperation.removed":
1306 if e.complexity.LabelChangeOperation.Removed == nil {
1307 break
1308 }
1309
1310 return e.complexity.LabelChangeOperation.Removed(childComplexity), true
1311
1312 case "LabelChangeResult.label":
1313 if e.complexity.LabelChangeResult.Label == nil {
1314 break
1315 }
1316
1317 return e.complexity.LabelChangeResult.Label(childComplexity), true
1318
1319 case "LabelChangeResult.status":
1320 if e.complexity.LabelChangeResult.Status == nil {
1321 break
1322 }
1323
1324 return e.complexity.LabelChangeResult.Status(childComplexity), true
1325
1326 case "LabelChangeTimelineItem.added":
1327 if e.complexity.LabelChangeTimelineItem.Added == nil {
1328 break
1329 }
1330
1331 return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
1332
1333 case "LabelChangeTimelineItem.author":
1334 if e.complexity.LabelChangeTimelineItem.Author == nil {
1335 break
1336 }
1337
1338 return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
1339
1340 case "LabelChangeTimelineItem.date":
1341 if e.complexity.LabelChangeTimelineItem.Date == nil {
1342 break
1343 }
1344
1345 return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
1346
1347 case "LabelChangeTimelineItem.id":
1348 if e.complexity.LabelChangeTimelineItem.ID == nil {
1349 break
1350 }
1351
1352 return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
1353
1354 case "LabelChangeTimelineItem.removed":
1355 if e.complexity.LabelChangeTimelineItem.Removed == nil {
1356 break
1357 }
1358
1359 return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
1360
1361 case "LabelConnection.edges":
1362 if e.complexity.LabelConnection.Edges == nil {
1363 break
1364 }
1365
1366 return e.complexity.LabelConnection.Edges(childComplexity), true
1367
1368 case "LabelConnection.nodes":
1369 if e.complexity.LabelConnection.Nodes == nil {
1370 break
1371 }
1372
1373 return e.complexity.LabelConnection.Nodes(childComplexity), true
1374
1375 case "LabelConnection.pageInfo":
1376 if e.complexity.LabelConnection.PageInfo == nil {
1377 break
1378 }
1379
1380 return e.complexity.LabelConnection.PageInfo(childComplexity), true
1381
1382 case "LabelConnection.totalCount":
1383 if e.complexity.LabelConnection.TotalCount == nil {
1384 break
1385 }
1386
1387 return e.complexity.LabelConnection.TotalCount(childComplexity), true
1388
1389 case "LabelEdge.cursor":
1390 if e.complexity.LabelEdge.Cursor == nil {
1391 break
1392 }
1393
1394 return e.complexity.LabelEdge.Cursor(childComplexity), true
1395
1396 case "LabelEdge.node":
1397 if e.complexity.LabelEdge.Node == nil {
1398 break
1399 }
1400
1401 return e.complexity.LabelEdge.Node(childComplexity), true
1402
1403 case "Mutation.addComment":
1404 if e.complexity.Mutation.AddComment == nil {
1405 break
1406 }
1407
1408 args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
1409 if err != nil {
1410 return 0, false
1411 }
1412
1413 return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
1414
1415 case "Mutation.addCommentAndClose":
1416 if e.complexity.Mutation.AddCommentAndClose == nil {
1417 break
1418 }
1419
1420 args, err := ec.field_Mutation_addCommentAndClose_args(context.TODO(), rawArgs)
1421 if err != nil {
1422 return 0, false
1423 }
1424
1425 return e.complexity.Mutation.AddCommentAndClose(childComplexity, args["input"].(models.AddCommentAndCloseBugInput)), true
1426
1427 case "Mutation.addCommentAndReopen":
1428 if e.complexity.Mutation.AddCommentAndReopen == nil {
1429 break
1430 }
1431
1432 args, err := ec.field_Mutation_addCommentAndReopen_args(context.TODO(), rawArgs)
1433 if err != nil {
1434 return 0, false
1435 }
1436
1437 return e.complexity.Mutation.AddCommentAndReopen(childComplexity, args["input"].(models.AddCommentAndReopenBugInput)), true
1438
1439 case "Mutation.changeLabels":
1440 if e.complexity.Mutation.ChangeLabels == nil {
1441 break
1442 }
1443
1444 args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
1445 if err != nil {
1446 return 0, false
1447 }
1448
1449 return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
1450
1451 case "Mutation.closeBug":
1452 if e.complexity.Mutation.CloseBug == nil {
1453 break
1454 }
1455
1456 args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
1457 if err != nil {
1458 return 0, false
1459 }
1460
1461 return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
1462
1463 case "Mutation.editComment":
1464 if e.complexity.Mutation.EditComment == nil {
1465 break
1466 }
1467
1468 args, err := ec.field_Mutation_editComment_args(context.TODO(), rawArgs)
1469 if err != nil {
1470 return 0, false
1471 }
1472
1473 return e.complexity.Mutation.EditComment(childComplexity, args["input"].(models.EditCommentInput)), true
1474
1475 case "Mutation.newBug":
1476 if e.complexity.Mutation.NewBug == nil {
1477 break
1478 }
1479
1480 args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
1481 if err != nil {
1482 return 0, false
1483 }
1484
1485 return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
1486
1487 case "Mutation.openBug":
1488 if e.complexity.Mutation.OpenBug == nil {
1489 break
1490 }
1491
1492 args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
1493 if err != nil {
1494 return 0, false
1495 }
1496
1497 return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
1498
1499 case "Mutation.setTitle":
1500 if e.complexity.Mutation.SetTitle == nil {
1501 break
1502 }
1503
1504 args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
1505 if err != nil {
1506 return 0, false
1507 }
1508
1509 return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
1510
1511 case "NewBugPayload.bug":
1512 if e.complexity.NewBugPayload.Bug == nil {
1513 break
1514 }
1515
1516 return e.complexity.NewBugPayload.Bug(childComplexity), true
1517
1518 case "NewBugPayload.clientMutationId":
1519 if e.complexity.NewBugPayload.ClientMutationID == nil {
1520 break
1521 }
1522
1523 return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
1524
1525 case "NewBugPayload.operation":
1526 if e.complexity.NewBugPayload.Operation == nil {
1527 break
1528 }
1529
1530 return e.complexity.NewBugPayload.Operation(childComplexity), true
1531
1532 case "OpenBugPayload.bug":
1533 if e.complexity.OpenBugPayload.Bug == nil {
1534 break
1535 }
1536
1537 return e.complexity.OpenBugPayload.Bug(childComplexity), true
1538
1539 case "OpenBugPayload.clientMutationId":
1540 if e.complexity.OpenBugPayload.ClientMutationID == nil {
1541 break
1542 }
1543
1544 return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
1545
1546 case "OpenBugPayload.operation":
1547 if e.complexity.OpenBugPayload.Operation == nil {
1548 break
1549 }
1550
1551 return e.complexity.OpenBugPayload.Operation(childComplexity), true
1552
1553 case "OperationConnection.edges":
1554 if e.complexity.OperationConnection.Edges == nil {
1555 break
1556 }
1557
1558 return e.complexity.OperationConnection.Edges(childComplexity), true
1559
1560 case "OperationConnection.nodes":
1561 if e.complexity.OperationConnection.Nodes == nil {
1562 break
1563 }
1564
1565 return e.complexity.OperationConnection.Nodes(childComplexity), true
1566
1567 case "OperationConnection.pageInfo":
1568 if e.complexity.OperationConnection.PageInfo == nil {
1569 break
1570 }
1571
1572 return e.complexity.OperationConnection.PageInfo(childComplexity), true
1573
1574 case "OperationConnection.totalCount":
1575 if e.complexity.OperationConnection.TotalCount == nil {
1576 break
1577 }
1578
1579 return e.complexity.OperationConnection.TotalCount(childComplexity), true
1580
1581 case "OperationEdge.cursor":
1582 if e.complexity.OperationEdge.Cursor == nil {
1583 break
1584 }
1585
1586 return e.complexity.OperationEdge.Cursor(childComplexity), true
1587
1588 case "OperationEdge.node":
1589 if e.complexity.OperationEdge.Node == nil {
1590 break
1591 }
1592
1593 return e.complexity.OperationEdge.Node(childComplexity), true
1594
1595 case "PageInfo.endCursor":
1596 if e.complexity.PageInfo.EndCursor == nil {
1597 break
1598 }
1599
1600 return e.complexity.PageInfo.EndCursor(childComplexity), true
1601
1602 case "PageInfo.hasNextPage":
1603 if e.complexity.PageInfo.HasNextPage == nil {
1604 break
1605 }
1606
1607 return e.complexity.PageInfo.HasNextPage(childComplexity), true
1608
1609 case "PageInfo.hasPreviousPage":
1610 if e.complexity.PageInfo.HasPreviousPage == nil {
1611 break
1612 }
1613
1614 return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
1615
1616 case "PageInfo.startCursor":
1617 if e.complexity.PageInfo.StartCursor == nil {
1618 break
1619 }
1620
1621 return e.complexity.PageInfo.StartCursor(childComplexity), true
1622
1623 case "Query.repository":
1624 if e.complexity.Query.Repository == nil {
1625 break
1626 }
1627
1628 args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
1629 if err != nil {
1630 return 0, false
1631 }
1632
1633 return e.complexity.Query.Repository(childComplexity, args["ref"].(*string)), true
1634
1635 case "Repository.allBugs":
1636 if e.complexity.Repository.AllBugs == nil {
1637 break
1638 }
1639
1640 args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
1641 if err != nil {
1642 return 0, false
1643 }
1644
1645 return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
1646
1647 case "Repository.allIdentities":
1648 if e.complexity.Repository.AllIdentities == nil {
1649 break
1650 }
1651
1652 args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
1653 if err != nil {
1654 return 0, false
1655 }
1656
1657 return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1658
1659 case "Repository.bug":
1660 if e.complexity.Repository.Bug == nil {
1661 break
1662 }
1663
1664 args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
1665 if err != nil {
1666 return 0, false
1667 }
1668
1669 return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
1670
1671 case "Repository.identity":
1672 if e.complexity.Repository.Identity == nil {
1673 break
1674 }
1675
1676 args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
1677 if err != nil {
1678 return 0, false
1679 }
1680
1681 return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
1682
1683 case "Repository.name":
1684 if e.complexity.Repository.Name == nil {
1685 break
1686 }
1687
1688 return e.complexity.Repository.Name(childComplexity), true
1689
1690 case "Repository.userIdentity":
1691 if e.complexity.Repository.UserIdentity == nil {
1692 break
1693 }
1694
1695 return e.complexity.Repository.UserIdentity(childComplexity), true
1696
1697 case "Repository.validLabels":
1698 if e.complexity.Repository.ValidLabels == nil {
1699 break
1700 }
1701
1702 args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
1703 if err != nil {
1704 return 0, false
1705 }
1706
1707 return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1708
1709 case "SetStatusOperation.author":
1710 if e.complexity.SetStatusOperation.Author == nil {
1711 break
1712 }
1713
1714 return e.complexity.SetStatusOperation.Author(childComplexity), true
1715
1716 case "SetStatusOperation.date":
1717 if e.complexity.SetStatusOperation.Date == nil {
1718 break
1719 }
1720
1721 return e.complexity.SetStatusOperation.Date(childComplexity), true
1722
1723 case "SetStatusOperation.id":
1724 if e.complexity.SetStatusOperation.ID == nil {
1725 break
1726 }
1727
1728 return e.complexity.SetStatusOperation.ID(childComplexity), true
1729
1730 case "SetStatusOperation.status":
1731 if e.complexity.SetStatusOperation.Status == nil {
1732 break
1733 }
1734
1735 return e.complexity.SetStatusOperation.Status(childComplexity), true
1736
1737 case "SetStatusTimelineItem.author":
1738 if e.complexity.SetStatusTimelineItem.Author == nil {
1739 break
1740 }
1741
1742 return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
1743
1744 case "SetStatusTimelineItem.date":
1745 if e.complexity.SetStatusTimelineItem.Date == nil {
1746 break
1747 }
1748
1749 return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
1750
1751 case "SetStatusTimelineItem.id":
1752 if e.complexity.SetStatusTimelineItem.ID == nil {
1753 break
1754 }
1755
1756 return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
1757
1758 case "SetStatusTimelineItem.status":
1759 if e.complexity.SetStatusTimelineItem.Status == nil {
1760 break
1761 }
1762
1763 return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
1764
1765 case "SetTitleOperation.author":
1766 if e.complexity.SetTitleOperation.Author == nil {
1767 break
1768 }
1769
1770 return e.complexity.SetTitleOperation.Author(childComplexity), true
1771
1772 case "SetTitleOperation.date":
1773 if e.complexity.SetTitleOperation.Date == nil {
1774 break
1775 }
1776
1777 return e.complexity.SetTitleOperation.Date(childComplexity), true
1778
1779 case "SetTitleOperation.id":
1780 if e.complexity.SetTitleOperation.ID == nil {
1781 break
1782 }
1783
1784 return e.complexity.SetTitleOperation.ID(childComplexity), true
1785
1786 case "SetTitleOperation.title":
1787 if e.complexity.SetTitleOperation.Title == nil {
1788 break
1789 }
1790
1791 return e.complexity.SetTitleOperation.Title(childComplexity), true
1792
1793 case "SetTitleOperation.was":
1794 if e.complexity.SetTitleOperation.Was == nil {
1795 break
1796 }
1797
1798 return e.complexity.SetTitleOperation.Was(childComplexity), true
1799
1800 case "SetTitlePayload.bug":
1801 if e.complexity.SetTitlePayload.Bug == nil {
1802 break
1803 }
1804
1805 return e.complexity.SetTitlePayload.Bug(childComplexity), true
1806
1807 case "SetTitlePayload.clientMutationId":
1808 if e.complexity.SetTitlePayload.ClientMutationID == nil {
1809 break
1810 }
1811
1812 return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
1813
1814 case "SetTitlePayload.operation":
1815 if e.complexity.SetTitlePayload.Operation == nil {
1816 break
1817 }
1818
1819 return e.complexity.SetTitlePayload.Operation(childComplexity), true
1820
1821 case "SetTitleTimelineItem.author":
1822 if e.complexity.SetTitleTimelineItem.Author == nil {
1823 break
1824 }
1825
1826 return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
1827
1828 case "SetTitleTimelineItem.date":
1829 if e.complexity.SetTitleTimelineItem.Date == nil {
1830 break
1831 }
1832
1833 return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
1834
1835 case "SetTitleTimelineItem.id":
1836 if e.complexity.SetTitleTimelineItem.ID == nil {
1837 break
1838 }
1839
1840 return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
1841
1842 case "SetTitleTimelineItem.title":
1843 if e.complexity.SetTitleTimelineItem.Title == nil {
1844 break
1845 }
1846
1847 return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
1848
1849 case "SetTitleTimelineItem.was":
1850 if e.complexity.SetTitleTimelineItem.Was == nil {
1851 break
1852 }
1853
1854 return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
1855
1856 case "TimelineItemConnection.edges":
1857 if e.complexity.TimelineItemConnection.Edges == nil {
1858 break
1859 }
1860
1861 return e.complexity.TimelineItemConnection.Edges(childComplexity), true
1862
1863 case "TimelineItemConnection.nodes":
1864 if e.complexity.TimelineItemConnection.Nodes == nil {
1865 break
1866 }
1867
1868 return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
1869
1870 case "TimelineItemConnection.pageInfo":
1871 if e.complexity.TimelineItemConnection.PageInfo == nil {
1872 break
1873 }
1874
1875 return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
1876
1877 case "TimelineItemConnection.totalCount":
1878 if e.complexity.TimelineItemConnection.TotalCount == nil {
1879 break
1880 }
1881
1882 return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
1883
1884 case "TimelineItemEdge.cursor":
1885 if e.complexity.TimelineItemEdge.Cursor == nil {
1886 break
1887 }
1888
1889 return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
1890
1891 case "TimelineItemEdge.node":
1892 if e.complexity.TimelineItemEdge.Node == nil {
1893 break
1894 }
1895
1896 return e.complexity.TimelineItemEdge.Node(childComplexity), true
1897
1898 }
1899 return 0, false
1900}
1901
1902func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
1903 rc := graphql.GetOperationContext(ctx)
1904 ec := executionContext{rc, e}
1905 first := true
1906
1907 switch rc.Operation.Operation {
1908 case ast.Query:
1909 return func(ctx context.Context) *graphql.Response {
1910 if !first {
1911 return nil
1912 }
1913 first = false
1914 data := ec._Query(ctx, rc.Operation.SelectionSet)
1915 var buf bytes.Buffer
1916 data.MarshalGQL(&buf)
1917
1918 return &graphql.Response{
1919 Data: buf.Bytes(),
1920 }
1921 }
1922 case ast.Mutation:
1923 return func(ctx context.Context) *graphql.Response {
1924 if !first {
1925 return nil
1926 }
1927 first = false
1928 data := ec._Mutation(ctx, rc.Operation.SelectionSet)
1929 var buf bytes.Buffer
1930 data.MarshalGQL(&buf)
1931
1932 return &graphql.Response{
1933 Data: buf.Bytes(),
1934 }
1935 }
1936
1937 default:
1938 return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
1939 }
1940}
1941
1942type executionContext struct {
1943 *graphql.OperationContext
1944 *executableSchema
1945}
1946
1947func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
1948 if ec.DisableIntrospection {
1949 return nil, errors.New("introspection disabled")
1950 }
1951 return introspection.WrapSchema(parsedSchema), nil
1952}
1953
1954func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
1955 if ec.DisableIntrospection {
1956 return nil, errors.New("introspection disabled")
1957 }
1958 return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
1959}
1960
1961var sources = []*ast.Source{
1962 {Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
1963type Comment implements Authored {
1964 """The author of this comment."""
1965 author: Identity!
1966
1967 """The message of this comment."""
1968 message: String!
1969
1970 """All media's hash referenced in this comment"""
1971 files: [Hash!]!
1972}
1973
1974type CommentConnection {
1975 edges: [CommentEdge!]!
1976 nodes: [Comment!]!
1977 pageInfo: PageInfo!
1978 totalCount: Int!
1979}
1980
1981type CommentEdge {
1982 cursor: String!
1983 node: Comment!
1984}
1985
1986enum Status {
1987 OPEN
1988 CLOSED
1989}
1990
1991type Bug implements Authored {
1992 """The identifier for this bug"""
1993 id: String!
1994 """The human version (truncated) identifier for this bug"""
1995 humanId: String!
1996 status: Status!
1997 title: String!
1998 labels: [Label!]!
1999 author: Identity!
2000 createdAt: Time!
2001 lastEdit: Time!
2002
2003 """The actors of the bug. Actors are Identity that have interacted with the bug."""
2004 actors(
2005 """Returns the elements in the list that come after the specified cursor."""
2006 after: String
2007 """Returns the elements in the list that come before the specified cursor."""
2008 before: String
2009 """Returns the first _n_ elements from the list."""
2010 first: Int
2011 """Returns the last _n_ elements from the list."""
2012 last: Int
2013 ): IdentityConnection!
2014
2015 """The participants of the bug. Participants are Identity that have created or
2016 added a comment on the bug."""
2017 participants(
2018 """Returns the elements in the list that come after the specified cursor."""
2019 after: String
2020 """Returns the elements in the list that come before the specified cursor."""
2021 before: String
2022 """Returns the first _n_ elements from the list."""
2023 first: Int
2024 """Returns the last _n_ elements from the list."""
2025 last: Int
2026 ): IdentityConnection!
2027
2028 comments(
2029 """Returns the elements in the list that come after the specified cursor."""
2030 after: String
2031 """Returns the elements in the list that come before the specified cursor."""
2032 before: String
2033 """Returns the first _n_ elements from the list."""
2034 first: Int
2035 """Returns the last _n_ elements from the list."""
2036 last: Int
2037 ): CommentConnection!
2038
2039 timeline(
2040 """Returns the elements in the list that come after the specified cursor."""
2041 after: String
2042 """Returns the elements in the list that come before the specified cursor."""
2043 before: String
2044 """Returns the first _n_ elements from the list."""
2045 first: Int
2046 """Returns the last _n_ elements from the list."""
2047 last: Int
2048 ): TimelineItemConnection!
2049
2050 operations(
2051 """Returns the elements in the list that come after the specified cursor."""
2052 after: String
2053 """Returns the elements in the list that come before the specified cursor."""
2054 before: String
2055 """Returns the first _n_ elements from the list."""
2056 first: Int
2057 """Returns the last _n_ elements from the list."""
2058 last: Int
2059 ): OperationConnection!
2060}
2061
2062"""The connection type for Bug."""
2063type BugConnection {
2064 """A list of edges."""
2065 edges: [BugEdge!]!
2066 nodes: [Bug!]!
2067 """Information to aid in pagination."""
2068 pageInfo: PageInfo!
2069 """Identifies the total count of items in the connection."""
2070 totalCount: Int!
2071}
2072
2073"""An edge in a connection."""
2074type BugEdge {
2075 """A cursor for use in pagination."""
2076 cursor: String!
2077 """The item at the end of the edge."""
2078 node: Bug!
2079}
2080`, BuiltIn: false},
2081 {Name: "schema/identity.graphql", Input: `"""Represents an identity"""
2082type Identity {
2083 """The identifier for this identity"""
2084 id: String!
2085 """The human version (truncated) identifier for this identity"""
2086 humanId: String!
2087 """The name of the person, if known."""
2088 name: String
2089 """The email of the person, if known."""
2090 email: String
2091 """The login of the person, if known."""
2092 login: String
2093 """A non-empty string to display, representing the identity, based on the non-empty values."""
2094 displayName: String!
2095 """An url to an avatar"""
2096 avatarUrl: String
2097 """isProtected is true if the chain of git commits started to be signed.
2098 If that's the case, only signed commit with a valid key for this identity can be added."""
2099 isProtected: Boolean!
2100}
2101
2102type IdentityConnection {
2103 edges: [IdentityEdge!]!
2104 nodes: [Identity!]!
2105 pageInfo: PageInfo!
2106 totalCount: Int!
2107}
2108
2109type IdentityEdge {
2110 cursor: String!
2111 node: Identity!
2112}`, BuiltIn: false},
2113 {Name: "schema/label.graphql", Input: `"""Label for a bug."""
2114type Label {
2115 """The name of the label."""
2116 name: String!
2117 """Color of the label."""
2118 color: Color!
2119}
2120
2121type LabelConnection {
2122 edges: [LabelEdge!]!
2123 nodes: [Label!]!
2124 pageInfo: PageInfo!
2125 totalCount: Int!
2126}
2127
2128type LabelEdge {
2129 cursor: String!
2130 node: Label!
2131}`, BuiltIn: false},
2132 {Name: "schema/mutations.graphql", Input: `input NewBugInput {
2133 """A unique identifier for the client performing the mutation."""
2134 clientMutationId: String
2135 """The name of the repository. If not set, the default repository is used."""
2136 repoRef: String
2137 """The title of the new bug."""
2138 title: String!
2139 """The first message of the new bug."""
2140 message: String!
2141 """The collection of file's hash required for the first message."""
2142 files: [Hash!]
2143}
2144
2145type NewBugPayload {
2146 """A unique identifier for the client performing the mutation."""
2147 clientMutationId: String
2148 """The created bug."""
2149 bug: Bug!
2150 """The resulting operation."""
2151 operation: CreateOperation!
2152}
2153
2154input AddCommentInput {
2155 """A unique identifier for the client performing the mutation."""
2156 clientMutationId: String
2157 """The name of the repository. If not set, the default repository is used."""
2158 repoRef: String
2159 """The bug ID's prefix."""
2160 prefix: String!
2161 """The message to be added to the bug."""
2162 message: String!
2163 """The collection of file's hash required for the first message."""
2164 files: [Hash!]
2165}
2166
2167type AddCommentPayload {
2168 """A unique identifier for the client performing the mutation."""
2169 clientMutationId: String
2170 """The affected bug."""
2171 bug: Bug!
2172 """The resulting operation."""
2173 operation: AddCommentOperation!
2174}
2175
2176input AddCommentAndCloseBugInput {
2177 """A unique identifier for the client performing the mutation."""
2178 clientMutationId: String
2179 """The name of the repository. If not set, the default repository is used."""
2180 repoRef: String
2181 """The bug ID's prefix."""
2182 prefix: String!
2183 """The message to be added to the bug."""
2184 message: String!
2185 """The collection of file's hash required for the first message."""
2186 files: [Hash!]
2187}
2188
2189type AddCommentAndCloseBugPayload {
2190 """A unique identifier for the client performing the mutation."""
2191 clientMutationId: String
2192 """The affected bug."""
2193 bug: Bug!
2194 """The resulting AddComment operation."""
2195 commentOperation: AddCommentOperation!
2196 """The resulting SetStatusOperation."""
2197 statusOperation: SetStatusOperation!
2198}
2199
2200input AddCommentAndReopenBugInput {
2201 """A unique identifier for the client performing the mutation."""
2202 clientMutationId: String
2203 """The name of the repository. If not set, the default repository is used."""
2204 repoRef: String
2205 """The bug ID's prefix."""
2206 prefix: String!
2207 """The message to be added to the bug."""
2208 message: String!
2209 """The collection of file's hash required for the first message."""
2210 files: [Hash!]
2211}
2212
2213type AddCommentAndReopenBugPayload {
2214 """A unique identifier for the client performing the mutation."""
2215 clientMutationId: String
2216 """The affected bug."""
2217 bug: Bug!
2218 """The resulting AddComment operation."""
2219 commentOperation: AddCommentOperation!
2220 """The resulting SetStatusOperation."""
2221 statusOperation: SetStatusOperation!
2222}
2223
2224input EditCommentInput {
2225 """A unique identifier for the client performing the mutation."""
2226 clientMutationId: String
2227 """The name of the repository. If not set, the default repository is used."""
2228 repoRef: String
2229 """The bug ID's prefix."""
2230 prefix: String!
2231 """The ID of the comment to be changed."""
2232 target: String!
2233 """The new message to be set."""
2234 message: String!
2235 """The collection of file's hash required for the first message."""
2236 files: [Hash!]
2237}
2238
2239type EditCommentPayload {
2240 """A unique identifier for the client performing the mutation."""
2241 clientMutationId: String
2242 """The affected bug."""
2243 bug: Bug!
2244 """The resulting operation."""
2245 operation: EditCommentOperation!
2246}
2247
2248input ChangeLabelInput {
2249 """A unique identifier for the client performing the mutation."""
2250 clientMutationId: String
2251 """The name of the repository. If not set, the default repository is used."""
2252 repoRef: String
2253 """The bug ID's prefix."""
2254 prefix: String!
2255 """The list of label to add."""
2256 added: [String!]
2257 """The list of label to remove."""
2258 Removed: [String!]
2259}
2260
2261enum LabelChangeStatus {
2262 ADDED
2263 REMOVED
2264 DUPLICATE_IN_OP
2265 ALREADY_EXIST
2266 DOESNT_EXIST
2267}
2268
2269type LabelChangeResult {
2270 """The source label."""
2271 label: Label!
2272 """The effect this label had."""
2273 status: LabelChangeStatus!
2274}
2275
2276type ChangeLabelPayload {
2277 """A unique identifier for the client performing the mutation."""
2278 clientMutationId: String
2279 """The affected bug."""
2280 bug: Bug!
2281 """The resulting operation."""
2282 operation: LabelChangeOperation!
2283 """The effect each source label had."""
2284 results: [LabelChangeResult]!
2285}
2286
2287input OpenBugInput {
2288 """A unique identifier for the client performing the mutation."""
2289 clientMutationId: String
2290 """The name of the repository. If not set, the default repository is used."""
2291 repoRef: String
2292 """The bug ID's prefix."""
2293 prefix: String!
2294}
2295
2296type OpenBugPayload {
2297 """A unique identifier for the client performing the mutation."""
2298 clientMutationId: String
2299 """The affected bug."""
2300 bug: Bug!
2301 """The resulting operation."""
2302 operation: SetStatusOperation!
2303}
2304
2305input CloseBugInput {
2306 """A unique identifier for the client performing the mutation."""
2307 clientMutationId: String
2308 """The name of the repository. If not set, the default repository is used."""
2309 repoRef: String
2310 """The bug ID's prefix."""
2311 prefix: String!
2312}
2313
2314type CloseBugPayload {
2315 """A unique identifier for the client performing the mutation."""
2316 clientMutationId: String
2317 """The affected bug."""
2318 bug: Bug!
2319 """The resulting operation."""
2320 operation: SetStatusOperation!
2321}
2322
2323input SetTitleInput {
2324 """A unique identifier for the client performing the mutation."""
2325 clientMutationId: String
2326 """The name of the repository. If not set, the default repository is used."""
2327 repoRef: String
2328 """The bug ID's prefix."""
2329 prefix: String!
2330 """The new title."""
2331 title: String!
2332}
2333
2334type SetTitlePayload {
2335 """A unique identifier for the client performing the mutation."""
2336 clientMutationId: String
2337 """The affected bug."""
2338 bug: Bug!
2339 """The resulting operation"""
2340 operation: SetTitleOperation!
2341}
2342`, BuiltIn: false},
2343 {Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
2344interface Operation {
2345 """The identifier of the operation"""
2346 id: String!
2347 """The operations author."""
2348 author: Identity!
2349 """The datetime when this operation was issued."""
2350 date: Time!
2351}
2352
2353# Connection
2354
2355"""The connection type for an Operation"""
2356type OperationConnection {
2357 edges: [OperationEdge!]!
2358 nodes: [Operation!]!
2359 pageInfo: PageInfo!
2360 totalCount: Int!
2361}
2362
2363"""Represent an Operation"""
2364type OperationEdge {
2365 cursor: String!
2366 node: Operation!
2367}
2368
2369# Operations
2370
2371type CreateOperation implements Operation & Authored {
2372 """The identifier of the operation"""
2373 id: String!
2374 """The author of this object."""
2375 author: Identity!
2376 """The datetime when this operation was issued."""
2377 date: Time!
2378
2379 title: String!
2380 message: String!
2381 files: [Hash!]!
2382}
2383
2384type SetTitleOperation implements Operation & Authored {
2385 """The identifier of the operation"""
2386 id: String!
2387 """The author of this object."""
2388 author: Identity!
2389 """The datetime when this operation was issued."""
2390 date: Time!
2391
2392 title: String!
2393 was: String!
2394}
2395
2396type AddCommentOperation implements Operation & Authored {
2397 """The identifier of the operation"""
2398 id: String!
2399 """The author of this object."""
2400 author: Identity!
2401 """The datetime when this operation was issued."""
2402 date: Time!
2403
2404 message: String!
2405 files: [Hash!]!
2406}
2407
2408type EditCommentOperation implements Operation & Authored {
2409 """The identifier of the operation"""
2410 id: String!
2411 """The author of this object."""
2412 author: Identity!
2413 """The datetime when this operation was issued."""
2414 date: Time!
2415
2416 target: String!
2417 message: String!
2418 files: [Hash!]!
2419}
2420
2421type SetStatusOperation implements Operation & Authored {
2422 """The identifier of the operation"""
2423 id: String!
2424 """The author of this object."""
2425 author: Identity!
2426 """The datetime when this operation was issued."""
2427 date: Time!
2428
2429 status: Status!
2430}
2431
2432type LabelChangeOperation implements Operation & Authored {
2433 """The identifier of the operation"""
2434 id: String!
2435 """The author of this object."""
2436 author: Identity!
2437 """The datetime when this operation was issued."""
2438 date: Time!
2439
2440 added: [Label!]!
2441 removed: [Label!]!
2442}
2443`, BuiltIn: false},
2444 {Name: "schema/repository.graphql", Input: `
2445type Repository {
2446 """The name of the repository"""
2447 name: String
2448
2449 """All the bugs"""
2450 allBugs(
2451 """Returns the elements in the list that come after the specified cursor."""
2452 after: String
2453 """Returns the elements in the list that come before the specified cursor."""
2454 before: String
2455 """Returns the first _n_ elements from the list."""
2456 first: Int
2457 """Returns the last _n_ elements from the list."""
2458 last: Int
2459 """A query to select and order bugs."""
2460 query: String
2461 ): BugConnection!
2462
2463 bug(prefix: String!): Bug
2464
2465 """All the identities"""
2466 allIdentities(
2467 """Returns the elements in the list that come after the specified cursor."""
2468 after: String
2469 """Returns the elements in the list that come before the specified cursor."""
2470 before: String
2471 """Returns the first _n_ elements from the list."""
2472 first: Int
2473 """Returns the last _n_ elements from the list."""
2474 last: Int
2475 ): IdentityConnection!
2476
2477 identity(prefix: String!): Identity
2478
2479 """The identity created or selected by the user as its own"""
2480 userIdentity: Identity
2481
2482 """List of valid labels."""
2483 validLabels(
2484 """Returns the elements in the list that come after the specified cursor."""
2485 after: String
2486 """Returns the elements in the list that come before the specified cursor."""
2487 before: String
2488 """Returns the first _n_ elements from the list."""
2489 first: Int
2490 """Returns the last _n_ elements from the list."""
2491 last: Int
2492 ): LabelConnection!
2493}
2494`, BuiltIn: false},
2495 {Name: "schema/root.graphql", Input: `type Query {
2496 """Access a repository by reference/name. If no ref is given, the default repository is returned if any."""
2497 repository(ref: String): Repository
2498}
2499
2500type Mutation {
2501 """Create a new bug"""
2502 newBug(input: NewBugInput!): NewBugPayload!
2503 """Add a new comment to a bug"""
2504 addComment(input: AddCommentInput!): AddCommentPayload!
2505 """Add a new comment to a bug and close it"""
2506 addCommentAndClose(input: AddCommentAndCloseBugInput!): AddCommentAndCloseBugPayload!
2507 """Add a new comment to a bug and reopen it"""
2508 addCommentAndReopen(input: AddCommentAndReopenBugInput!): AddCommentAndReopenBugPayload!
2509 """Change a comment of a bug"""
2510 editComment(input: EditCommentInput!): EditCommentPayload!
2511 """Add or remove a set of label on a bug"""
2512 changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
2513 """Change a bug's status to open"""
2514 openBug(input: OpenBugInput!): OpenBugPayload!
2515 """Change a bug's status to closed"""
2516 closeBug(input: CloseBugInput!): CloseBugPayload!
2517 """Change a bug's title"""
2518 setTitle(input: SetTitleInput!): SetTitlePayload!
2519}
2520`, BuiltIn: false},
2521 {Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
2522interface TimelineItem {
2523 """The identifier of the source operation"""
2524 id: String!
2525}
2526
2527"""CommentHistoryStep hold one version of a message in the history"""
2528type CommentHistoryStep {
2529 message: String!
2530 date: Time!
2531}
2532
2533# Connection
2534
2535"""The connection type for TimelineItem"""
2536type TimelineItemConnection {
2537 edges: [TimelineItemEdge!]!
2538 nodes: [TimelineItem!]!
2539 pageInfo: PageInfo!
2540 totalCount: Int!
2541}
2542
2543"""Represent a TimelineItem"""
2544type TimelineItemEdge {
2545 cursor: String!
2546 node: TimelineItem!
2547}
2548
2549# Items
2550
2551"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
2552type CreateTimelineItem implements TimelineItem & Authored {
2553 """The identifier of the source operation"""
2554 id: String!
2555 author: Identity!
2556 message: String!
2557 messageIsEmpty: Boolean!
2558 files: [Hash!]!
2559 createdAt: Time!
2560 lastEdit: Time!
2561 edited: Boolean!
2562 history: [CommentHistoryStep!]!
2563}
2564
2565"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
2566type AddCommentTimelineItem 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"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
2580type LabelChangeTimelineItem implements TimelineItem & Authored {
2581 """The identifier of the source operation"""
2582 id: String!
2583 author: Identity!
2584 date: Time!
2585 added: [Label!]!
2586 removed: [Label!]!
2587}
2588
2589"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
2590type SetStatusTimelineItem implements TimelineItem & Authored {
2591 """The identifier of the source operation"""
2592 id: String!
2593 author: Identity!
2594 date: Time!
2595 status: Status!
2596}
2597
2598"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
2599type SetTitleTimelineItem implements TimelineItem & Authored {
2600 """The identifier of the source operation"""
2601 id: String!
2602 author: Identity!
2603 date: Time!
2604 title: String!
2605 was: String!
2606}
2607`, BuiltIn: false},
2608 {Name: "schema/types.graphql", Input: `scalar Time
2609scalar Hash
2610
2611"""Defines a color by red, green and blue components."""
2612type Color {
2613 """Red component of the color."""
2614 R: Int!
2615 """Green component of the color."""
2616 G: Int!
2617 """Blue component of the color."""
2618 B: Int!
2619}
2620
2621"""Information about pagination in a connection."""
2622type PageInfo {
2623 """When paginating forwards, are there more items?"""
2624 hasNextPage: Boolean!
2625 """When paginating backwards, are there more items?"""
2626 hasPreviousPage: Boolean!
2627 """When paginating backwards, the cursor to continue."""
2628 startCursor: String!
2629 """When paginating forwards, the cursor to continue."""
2630 endCursor: String!
2631}
2632
2633"""An object that has an author."""
2634interface Authored {
2635 """The author of this object."""
2636 author: Identity!
2637}
2638`, BuiltIn: false},
2639}
2640var parsedSchema = gqlparser.MustLoadSchema(sources...)
2641
2642// endregion ************************** generated!.gotpl **************************
2643
2644// region ***************************** args.gotpl *****************************
2645
2646func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2647 var err error
2648 args := map[string]interface{}{}
2649 var arg0 *string
2650 if tmp, ok := rawArgs["after"]; ok {
2651 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
2652 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2653 if err != nil {
2654 return nil, err
2655 }
2656 }
2657 args["after"] = arg0
2658 var arg1 *string
2659 if tmp, ok := rawArgs["before"]; ok {
2660 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
2661 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2662 if err != nil {
2663 return nil, err
2664 }
2665 }
2666 args["before"] = arg1
2667 var arg2 *int
2668 if tmp, ok := rawArgs["first"]; ok {
2669 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
2670 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2671 if err != nil {
2672 return nil, err
2673 }
2674 }
2675 args["first"] = arg2
2676 var arg3 *int
2677 if tmp, ok := rawArgs["last"]; ok {
2678 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
2679 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2680 if err != nil {
2681 return nil, err
2682 }
2683 }
2684 args["last"] = arg3
2685 return args, nil
2686}
2687
2688func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2689 var err error
2690 args := map[string]interface{}{}
2691 var arg0 *string
2692 if tmp, ok := rawArgs["after"]; ok {
2693 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
2694 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2695 if err != nil {
2696 return nil, err
2697 }
2698 }
2699 args["after"] = arg0
2700 var arg1 *string
2701 if tmp, ok := rawArgs["before"]; ok {
2702 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
2703 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2704 if err != nil {
2705 return nil, err
2706 }
2707 }
2708 args["before"] = arg1
2709 var arg2 *int
2710 if tmp, ok := rawArgs["first"]; ok {
2711 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
2712 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2713 if err != nil {
2714 return nil, err
2715 }
2716 }
2717 args["first"] = arg2
2718 var arg3 *int
2719 if tmp, ok := rawArgs["last"]; ok {
2720 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
2721 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2722 if err != nil {
2723 return nil, err
2724 }
2725 }
2726 args["last"] = arg3
2727 return args, nil
2728}
2729
2730func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2731 var err error
2732 args := map[string]interface{}{}
2733 var arg0 *string
2734 if tmp, ok := rawArgs["after"]; ok {
2735 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
2736 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2737 if err != nil {
2738 return nil, err
2739 }
2740 }
2741 args["after"] = arg0
2742 var arg1 *string
2743 if tmp, ok := rawArgs["before"]; ok {
2744 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
2745 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2746 if err != nil {
2747 return nil, err
2748 }
2749 }
2750 args["before"] = arg1
2751 var arg2 *int
2752 if tmp, ok := rawArgs["first"]; ok {
2753 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
2754 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2755 if err != nil {
2756 return nil, err
2757 }
2758 }
2759 args["first"] = arg2
2760 var arg3 *int
2761 if tmp, ok := rawArgs["last"]; ok {
2762 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
2763 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2764 if err != nil {
2765 return nil, err
2766 }
2767 }
2768 args["last"] = arg3
2769 return args, nil
2770}
2771
2772func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2773 var err error
2774 args := map[string]interface{}{}
2775 var arg0 *string
2776 if tmp, ok := rawArgs["after"]; ok {
2777 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
2778 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2779 if err != nil {
2780 return nil, err
2781 }
2782 }
2783 args["after"] = arg0
2784 var arg1 *string
2785 if tmp, ok := rawArgs["before"]; ok {
2786 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
2787 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2788 if err != nil {
2789 return nil, err
2790 }
2791 }
2792 args["before"] = arg1
2793 var arg2 *int
2794 if tmp, ok := rawArgs["first"]; ok {
2795 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
2796 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2797 if err != nil {
2798 return nil, err
2799 }
2800 }
2801 args["first"] = arg2
2802 var arg3 *int
2803 if tmp, ok := rawArgs["last"]; ok {
2804 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
2805 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2806 if err != nil {
2807 return nil, err
2808 }
2809 }
2810 args["last"] = arg3
2811 return args, nil
2812}
2813
2814func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2815 var err error
2816 args := map[string]interface{}{}
2817 var arg0 *string
2818 if tmp, ok := rawArgs["after"]; ok {
2819 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
2820 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2821 if err != nil {
2822 return nil, err
2823 }
2824 }
2825 args["after"] = arg0
2826 var arg1 *string
2827 if tmp, ok := rawArgs["before"]; ok {
2828 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
2829 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2830 if err != nil {
2831 return nil, err
2832 }
2833 }
2834 args["before"] = arg1
2835 var arg2 *int
2836 if tmp, ok := rawArgs["first"]; ok {
2837 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
2838 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2839 if err != nil {
2840 return nil, err
2841 }
2842 }
2843 args["first"] = arg2
2844 var arg3 *int
2845 if tmp, ok := rawArgs["last"]; ok {
2846 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
2847 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2848 if err != nil {
2849 return nil, err
2850 }
2851 }
2852 args["last"] = arg3
2853 return args, nil
2854}
2855
2856func (ec *executionContext) field_Mutation_addCommentAndClose_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2857 var err error
2858 args := map[string]interface{}{}
2859 var arg0 models.AddCommentAndCloseBugInput
2860 if tmp, ok := rawArgs["input"]; ok {
2861 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2862 arg0, err = ec.unmarshalNAddCommentAndCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugInput(ctx, tmp)
2863 if err != nil {
2864 return nil, err
2865 }
2866 }
2867 args["input"] = arg0
2868 return args, nil
2869}
2870
2871func (ec *executionContext) field_Mutation_addCommentAndReopen_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2872 var err error
2873 args := map[string]interface{}{}
2874 var arg0 models.AddCommentAndReopenBugInput
2875 if tmp, ok := rawArgs["input"]; ok {
2876 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2877 arg0, err = ec.unmarshalNAddCommentAndReopenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugInput(ctx, tmp)
2878 if err != nil {
2879 return nil, err
2880 }
2881 }
2882 args["input"] = arg0
2883 return args, nil
2884}
2885
2886func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2887 var err error
2888 args := map[string]interface{}{}
2889 var arg0 models.AddCommentInput
2890 if tmp, ok := rawArgs["input"]; ok {
2891 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2892 arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
2893 if err != nil {
2894 return nil, err
2895 }
2896 }
2897 args["input"] = arg0
2898 return args, nil
2899}
2900
2901func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2902 var err error
2903 args := map[string]interface{}{}
2904 var arg0 *models.ChangeLabelInput
2905 if tmp, ok := rawArgs["input"]; ok {
2906 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2907 arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
2908 if err != nil {
2909 return nil, err
2910 }
2911 }
2912 args["input"] = arg0
2913 return args, nil
2914}
2915
2916func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2917 var err error
2918 args := map[string]interface{}{}
2919 var arg0 models.CloseBugInput
2920 if tmp, ok := rawArgs["input"]; ok {
2921 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2922 arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
2923 if err != nil {
2924 return nil, err
2925 }
2926 }
2927 args["input"] = arg0
2928 return args, nil
2929}
2930
2931func (ec *executionContext) field_Mutation_editComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2932 var err error
2933 args := map[string]interface{}{}
2934 var arg0 models.EditCommentInput
2935 if tmp, ok := rawArgs["input"]; ok {
2936 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2937 arg0, err = ec.unmarshalNEditCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx, tmp)
2938 if err != nil {
2939 return nil, err
2940 }
2941 }
2942 args["input"] = arg0
2943 return args, nil
2944}
2945
2946func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2947 var err error
2948 args := map[string]interface{}{}
2949 var arg0 models.NewBugInput
2950 if tmp, ok := rawArgs["input"]; ok {
2951 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2952 arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
2953 if err != nil {
2954 return nil, err
2955 }
2956 }
2957 args["input"] = arg0
2958 return args, nil
2959}
2960
2961func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2962 var err error
2963 args := map[string]interface{}{}
2964 var arg0 models.OpenBugInput
2965 if tmp, ok := rawArgs["input"]; ok {
2966 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2967 arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
2968 if err != nil {
2969 return nil, err
2970 }
2971 }
2972 args["input"] = arg0
2973 return args, nil
2974}
2975
2976func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2977 var err error
2978 args := map[string]interface{}{}
2979 var arg0 models.SetTitleInput
2980 if tmp, ok := rawArgs["input"]; ok {
2981 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2982 arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
2983 if err != nil {
2984 return nil, err
2985 }
2986 }
2987 args["input"] = arg0
2988 return args, nil
2989}
2990
2991func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2992 var err error
2993 args := map[string]interface{}{}
2994 var arg0 string
2995 if tmp, ok := rawArgs["name"]; ok {
2996 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
2997 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2998 if err != nil {
2999 return nil, err
3000 }
3001 }
3002 args["name"] = arg0
3003 return args, nil
3004}
3005
3006func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3007 var err error
3008 args := map[string]interface{}{}
3009 var arg0 *string
3010 if tmp, ok := rawArgs["ref"]; ok {
3011 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref"))
3012 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3013 if err != nil {
3014 return nil, err
3015 }
3016 }
3017 args["ref"] = arg0
3018 return args, nil
3019}
3020
3021func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3022 var err error
3023 args := map[string]interface{}{}
3024 var arg0 *string
3025 if tmp, ok := rawArgs["after"]; ok {
3026 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
3027 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3028 if err != nil {
3029 return nil, err
3030 }
3031 }
3032 args["after"] = arg0
3033 var arg1 *string
3034 if tmp, ok := rawArgs["before"]; ok {
3035 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
3036 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3037 if err != nil {
3038 return nil, err
3039 }
3040 }
3041 args["before"] = arg1
3042 var arg2 *int
3043 if tmp, ok := rawArgs["first"]; ok {
3044 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
3045 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3046 if err != nil {
3047 return nil, err
3048 }
3049 }
3050 args["first"] = arg2
3051 var arg3 *int
3052 if tmp, ok := rawArgs["last"]; ok {
3053 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
3054 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3055 if err != nil {
3056 return nil, err
3057 }
3058 }
3059 args["last"] = arg3
3060 var arg4 *string
3061 if tmp, ok := rawArgs["query"]; ok {
3062 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("query"))
3063 arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3064 if err != nil {
3065 return nil, err
3066 }
3067 }
3068 args["query"] = arg4
3069 return args, nil
3070}
3071
3072func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3073 var err error
3074 args := map[string]interface{}{}
3075 var arg0 *string
3076 if tmp, ok := rawArgs["after"]; ok {
3077 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
3078 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3079 if err != nil {
3080 return nil, err
3081 }
3082 }
3083 args["after"] = arg0
3084 var arg1 *string
3085 if tmp, ok := rawArgs["before"]; ok {
3086 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
3087 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3088 if err != nil {
3089 return nil, err
3090 }
3091 }
3092 args["before"] = arg1
3093 var arg2 *int
3094 if tmp, ok := rawArgs["first"]; ok {
3095 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
3096 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3097 if err != nil {
3098 return nil, err
3099 }
3100 }
3101 args["first"] = arg2
3102 var arg3 *int
3103 if tmp, ok := rawArgs["last"]; ok {
3104 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
3105 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3106 if err != nil {
3107 return nil, err
3108 }
3109 }
3110 args["last"] = arg3
3111 return args, nil
3112}
3113
3114func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3115 var err error
3116 args := map[string]interface{}{}
3117 var arg0 string
3118 if tmp, ok := rawArgs["prefix"]; ok {
3119 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
3120 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3121 if err != nil {
3122 return nil, err
3123 }
3124 }
3125 args["prefix"] = arg0
3126 return args, nil
3127}
3128
3129func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3130 var err error
3131 args := map[string]interface{}{}
3132 var arg0 string
3133 if tmp, ok := rawArgs["prefix"]; ok {
3134 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
3135 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3136 if err != nil {
3137 return nil, err
3138 }
3139 }
3140 args["prefix"] = arg0
3141 return args, nil
3142}
3143
3144func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3145 var err error
3146 args := map[string]interface{}{}
3147 var arg0 *string
3148 if tmp, ok := rawArgs["after"]; ok {
3149 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
3150 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3151 if err != nil {
3152 return nil, err
3153 }
3154 }
3155 args["after"] = arg0
3156 var arg1 *string
3157 if tmp, ok := rawArgs["before"]; ok {
3158 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
3159 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3160 if err != nil {
3161 return nil, err
3162 }
3163 }
3164 args["before"] = arg1
3165 var arg2 *int
3166 if tmp, ok := rawArgs["first"]; ok {
3167 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
3168 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3169 if err != nil {
3170 return nil, err
3171 }
3172 }
3173 args["first"] = arg2
3174 var arg3 *int
3175 if tmp, ok := rawArgs["last"]; ok {
3176 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
3177 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3178 if err != nil {
3179 return nil, err
3180 }
3181 }
3182 args["last"] = arg3
3183 return args, nil
3184}
3185
3186func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3187 var err error
3188 args := map[string]interface{}{}
3189 var arg0 bool
3190 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3191 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
3192 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3193 if err != nil {
3194 return nil, err
3195 }
3196 }
3197 args["includeDeprecated"] = arg0
3198 return args, nil
3199}
3200
3201func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3202 var err error
3203 args := map[string]interface{}{}
3204 var arg0 bool
3205 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3206 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
3207 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3208 if err != nil {
3209 return nil, err
3210 }
3211 }
3212 args["includeDeprecated"] = arg0
3213 return args, nil
3214}
3215
3216// endregion ***************************** args.gotpl *****************************
3217
3218// region ************************** directives.gotpl **************************
3219
3220// endregion ************************** directives.gotpl **************************
3221
3222// region **************************** field.gotpl *****************************
3223
3224func (ec *executionContext) _AddCommentAndCloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3225 defer func() {
3226 if r := recover(); r != nil {
3227 ec.Error(ctx, ec.Recover(ctx, r))
3228 ret = graphql.Null
3229 }
3230 }()
3231 fc := &graphql.FieldContext{
3232 Object: "AddCommentAndCloseBugPayload",
3233 Field: field,
3234 Args: nil,
3235 IsMethod: false,
3236 IsResolver: false,
3237 }
3238
3239 ctx = graphql.WithFieldContext(ctx, fc)
3240 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3241 ctx = rctx // use context from middleware stack in children
3242 return obj.ClientMutationID, nil
3243 })
3244 if err != nil {
3245 ec.Error(ctx, err)
3246 return graphql.Null
3247 }
3248 if resTmp == nil {
3249 return graphql.Null
3250 }
3251 res := resTmp.(*string)
3252 fc.Result = res
3253 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3254}
3255
3256func (ec *executionContext) _AddCommentAndCloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3257 defer func() {
3258 if r := recover(); r != nil {
3259 ec.Error(ctx, ec.Recover(ctx, r))
3260 ret = graphql.Null
3261 }
3262 }()
3263 fc := &graphql.FieldContext{
3264 Object: "AddCommentAndCloseBugPayload",
3265 Field: field,
3266 Args: nil,
3267 IsMethod: false,
3268 IsResolver: false,
3269 }
3270
3271 ctx = graphql.WithFieldContext(ctx, fc)
3272 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3273 ctx = rctx // use context from middleware stack in children
3274 return obj.Bug, nil
3275 })
3276 if err != nil {
3277 ec.Error(ctx, err)
3278 return graphql.Null
3279 }
3280 if resTmp == nil {
3281 if !graphql.HasFieldError(ctx, fc) {
3282 ec.Errorf(ctx, "must not be null")
3283 }
3284 return graphql.Null
3285 }
3286 res := resTmp.(models.BugWrapper)
3287 fc.Result = res
3288 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
3289}
3290
3291func (ec *executionContext) _AddCommentAndCloseBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3292 defer func() {
3293 if r := recover(); r != nil {
3294 ec.Error(ctx, ec.Recover(ctx, r))
3295 ret = graphql.Null
3296 }
3297 }()
3298 fc := &graphql.FieldContext{
3299 Object: "AddCommentAndCloseBugPayload",
3300 Field: field,
3301 Args: nil,
3302 IsMethod: false,
3303 IsResolver: false,
3304 }
3305
3306 ctx = graphql.WithFieldContext(ctx, fc)
3307 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3308 ctx = rctx // use context from middleware stack in children
3309 return obj.CommentOperation, nil
3310 })
3311 if err != nil {
3312 ec.Error(ctx, err)
3313 return graphql.Null
3314 }
3315 if resTmp == nil {
3316 if !graphql.HasFieldError(ctx, fc) {
3317 ec.Errorf(ctx, "must not be null")
3318 }
3319 return graphql.Null
3320 }
3321 res := resTmp.(*bug.AddCommentOperation)
3322 fc.Result = res
3323 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3324}
3325
3326func (ec *executionContext) _AddCommentAndCloseBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3327 defer func() {
3328 if r := recover(); r != nil {
3329 ec.Error(ctx, ec.Recover(ctx, r))
3330 ret = graphql.Null
3331 }
3332 }()
3333 fc := &graphql.FieldContext{
3334 Object: "AddCommentAndCloseBugPayload",
3335 Field: field,
3336 Args: nil,
3337 IsMethod: false,
3338 IsResolver: false,
3339 }
3340
3341 ctx = graphql.WithFieldContext(ctx, fc)
3342 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3343 ctx = rctx // use context from middleware stack in children
3344 return obj.StatusOperation, nil
3345 })
3346 if err != nil {
3347 ec.Error(ctx, err)
3348 return graphql.Null
3349 }
3350 if resTmp == nil {
3351 if !graphql.HasFieldError(ctx, fc) {
3352 ec.Errorf(ctx, "must not be null")
3353 }
3354 return graphql.Null
3355 }
3356 res := resTmp.(*bug.SetStatusOperation)
3357 fc.Result = res
3358 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
3359}
3360
3361func (ec *executionContext) _AddCommentAndReopenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
3362 defer func() {
3363 if r := recover(); r != nil {
3364 ec.Error(ctx, ec.Recover(ctx, r))
3365 ret = graphql.Null
3366 }
3367 }()
3368 fc := &graphql.FieldContext{
3369 Object: "AddCommentAndReopenBugPayload",
3370 Field: field,
3371 Args: nil,
3372 IsMethod: false,
3373 IsResolver: false,
3374 }
3375
3376 ctx = graphql.WithFieldContext(ctx, fc)
3377 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3378 ctx = rctx // use context from middleware stack in children
3379 return obj.ClientMutationID, nil
3380 })
3381 if err != nil {
3382 ec.Error(ctx, err)
3383 return graphql.Null
3384 }
3385 if resTmp == nil {
3386 return graphql.Null
3387 }
3388 res := resTmp.(*string)
3389 fc.Result = res
3390 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3391}
3392
3393func (ec *executionContext) _AddCommentAndReopenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
3394 defer func() {
3395 if r := recover(); r != nil {
3396 ec.Error(ctx, ec.Recover(ctx, r))
3397 ret = graphql.Null
3398 }
3399 }()
3400 fc := &graphql.FieldContext{
3401 Object: "AddCommentAndReopenBugPayload",
3402 Field: field,
3403 Args: nil,
3404 IsMethod: false,
3405 IsResolver: false,
3406 }
3407
3408 ctx = graphql.WithFieldContext(ctx, fc)
3409 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3410 ctx = rctx // use context from middleware stack in children
3411 return obj.Bug, nil
3412 })
3413 if err != nil {
3414 ec.Error(ctx, err)
3415 return graphql.Null
3416 }
3417 if resTmp == nil {
3418 if !graphql.HasFieldError(ctx, fc) {
3419 ec.Errorf(ctx, "must not be null")
3420 }
3421 return graphql.Null
3422 }
3423 res := resTmp.(models.BugWrapper)
3424 fc.Result = res
3425 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
3426}
3427
3428func (ec *executionContext) _AddCommentAndReopenBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
3429 defer func() {
3430 if r := recover(); r != nil {
3431 ec.Error(ctx, ec.Recover(ctx, r))
3432 ret = graphql.Null
3433 }
3434 }()
3435 fc := &graphql.FieldContext{
3436 Object: "AddCommentAndReopenBugPayload",
3437 Field: field,
3438 Args: nil,
3439 IsMethod: false,
3440 IsResolver: false,
3441 }
3442
3443 ctx = graphql.WithFieldContext(ctx, fc)
3444 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3445 ctx = rctx // use context from middleware stack in children
3446 return obj.CommentOperation, nil
3447 })
3448 if err != nil {
3449 ec.Error(ctx, err)
3450 return graphql.Null
3451 }
3452 if resTmp == nil {
3453 if !graphql.HasFieldError(ctx, fc) {
3454 ec.Errorf(ctx, "must not be null")
3455 }
3456 return graphql.Null
3457 }
3458 res := resTmp.(*bug.AddCommentOperation)
3459 fc.Result = res
3460 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3461}
3462
3463func (ec *executionContext) _AddCommentAndReopenBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
3464 defer func() {
3465 if r := recover(); r != nil {
3466 ec.Error(ctx, ec.Recover(ctx, r))
3467 ret = graphql.Null
3468 }
3469 }()
3470 fc := &graphql.FieldContext{
3471 Object: "AddCommentAndReopenBugPayload",
3472 Field: field,
3473 Args: nil,
3474 IsMethod: false,
3475 IsResolver: false,
3476 }
3477
3478 ctx = graphql.WithFieldContext(ctx, fc)
3479 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3480 ctx = rctx // use context from middleware stack in children
3481 return obj.StatusOperation, nil
3482 })
3483 if err != nil {
3484 ec.Error(ctx, err)
3485 return graphql.Null
3486 }
3487 if resTmp == nil {
3488 if !graphql.HasFieldError(ctx, fc) {
3489 ec.Errorf(ctx, "must not be null")
3490 }
3491 return graphql.Null
3492 }
3493 res := resTmp.(*bug.SetStatusOperation)
3494 fc.Result = res
3495 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
3496}
3497
3498func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3499 defer func() {
3500 if r := recover(); r != nil {
3501 ec.Error(ctx, ec.Recover(ctx, r))
3502 ret = graphql.Null
3503 }
3504 }()
3505 fc := &graphql.FieldContext{
3506 Object: "AddCommentOperation",
3507 Field: field,
3508 Args: nil,
3509 IsMethod: true,
3510 IsResolver: true,
3511 }
3512
3513 ctx = graphql.WithFieldContext(ctx, fc)
3514 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3515 ctx = rctx // use context from middleware stack in children
3516 return ec.resolvers.AddCommentOperation().ID(rctx, obj)
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.(string)
3529 fc.Result = res
3530 return ec.marshalNString2string(ctx, field.Selections, res)
3531}
3532
3533func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3534 defer func() {
3535 if r := recover(); r != nil {
3536 ec.Error(ctx, ec.Recover(ctx, r))
3537 ret = graphql.Null
3538 }
3539 }()
3540 fc := &graphql.FieldContext{
3541 Object: "AddCommentOperation",
3542 Field: field,
3543 Args: nil,
3544 IsMethod: true,
3545 IsResolver: true,
3546 }
3547
3548 ctx = graphql.WithFieldContext(ctx, fc)
3549 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3550 ctx = rctx // use context from middleware stack in children
3551 return ec.resolvers.AddCommentOperation().Author(rctx, obj)
3552 })
3553 if err != nil {
3554 ec.Error(ctx, err)
3555 return graphql.Null
3556 }
3557 if resTmp == nil {
3558 if !graphql.HasFieldError(ctx, fc) {
3559 ec.Errorf(ctx, "must not be null")
3560 }
3561 return graphql.Null
3562 }
3563 res := resTmp.(models.IdentityWrapper)
3564 fc.Result = res
3565 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3566}
3567
3568func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3569 defer func() {
3570 if r := recover(); r != nil {
3571 ec.Error(ctx, ec.Recover(ctx, r))
3572 ret = graphql.Null
3573 }
3574 }()
3575 fc := &graphql.FieldContext{
3576 Object: "AddCommentOperation",
3577 Field: field,
3578 Args: nil,
3579 IsMethod: true,
3580 IsResolver: true,
3581 }
3582
3583 ctx = graphql.WithFieldContext(ctx, fc)
3584 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3585 ctx = rctx // use context from middleware stack in children
3586 return ec.resolvers.AddCommentOperation().Date(rctx, obj)
3587 })
3588 if err != nil {
3589 ec.Error(ctx, err)
3590 return graphql.Null
3591 }
3592 if resTmp == nil {
3593 if !graphql.HasFieldError(ctx, fc) {
3594 ec.Errorf(ctx, "must not be null")
3595 }
3596 return graphql.Null
3597 }
3598 res := resTmp.(*time.Time)
3599 fc.Result = res
3600 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3601}
3602
3603func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3604 defer func() {
3605 if r := recover(); r != nil {
3606 ec.Error(ctx, ec.Recover(ctx, r))
3607 ret = graphql.Null
3608 }
3609 }()
3610 fc := &graphql.FieldContext{
3611 Object: "AddCommentOperation",
3612 Field: field,
3613 Args: nil,
3614 IsMethod: false,
3615 IsResolver: false,
3616 }
3617
3618 ctx = graphql.WithFieldContext(ctx, fc)
3619 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3620 ctx = rctx // use context from middleware stack in children
3621 return obj.Message, nil
3622 })
3623 if err != nil {
3624 ec.Error(ctx, err)
3625 return graphql.Null
3626 }
3627 if resTmp == nil {
3628 if !graphql.HasFieldError(ctx, fc) {
3629 ec.Errorf(ctx, "must not be null")
3630 }
3631 return graphql.Null
3632 }
3633 res := resTmp.(string)
3634 fc.Result = res
3635 return ec.marshalNString2string(ctx, field.Selections, res)
3636}
3637
3638func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3639 defer func() {
3640 if r := recover(); r != nil {
3641 ec.Error(ctx, ec.Recover(ctx, r))
3642 ret = graphql.Null
3643 }
3644 }()
3645 fc := &graphql.FieldContext{
3646 Object: "AddCommentOperation",
3647 Field: field,
3648 Args: nil,
3649 IsMethod: false,
3650 IsResolver: false,
3651 }
3652
3653 ctx = graphql.WithFieldContext(ctx, fc)
3654 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3655 ctx = rctx // use context from middleware stack in children
3656 return obj.Files, nil
3657 })
3658 if err != nil {
3659 ec.Error(ctx, err)
3660 return graphql.Null
3661 }
3662 if resTmp == nil {
3663 if !graphql.HasFieldError(ctx, fc) {
3664 ec.Errorf(ctx, "must not be null")
3665 }
3666 return graphql.Null
3667 }
3668 res := resTmp.([]repository.Hash)
3669 fc.Result = res
3670 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
3671}
3672
3673func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3674 defer func() {
3675 if r := recover(); r != nil {
3676 ec.Error(ctx, ec.Recover(ctx, r))
3677 ret = graphql.Null
3678 }
3679 }()
3680 fc := &graphql.FieldContext{
3681 Object: "AddCommentPayload",
3682 Field: field,
3683 Args: nil,
3684 IsMethod: false,
3685 IsResolver: false,
3686 }
3687
3688 ctx = graphql.WithFieldContext(ctx, fc)
3689 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3690 ctx = rctx // use context from middleware stack in children
3691 return obj.ClientMutationID, nil
3692 })
3693 if err != nil {
3694 ec.Error(ctx, err)
3695 return graphql.Null
3696 }
3697 if resTmp == nil {
3698 return graphql.Null
3699 }
3700 res := resTmp.(*string)
3701 fc.Result = res
3702 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3703}
3704
3705func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3706 defer func() {
3707 if r := recover(); r != nil {
3708 ec.Error(ctx, ec.Recover(ctx, r))
3709 ret = graphql.Null
3710 }
3711 }()
3712 fc := &graphql.FieldContext{
3713 Object: "AddCommentPayload",
3714 Field: field,
3715 Args: nil,
3716 IsMethod: false,
3717 IsResolver: false,
3718 }
3719
3720 ctx = graphql.WithFieldContext(ctx, fc)
3721 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3722 ctx = rctx // use context from middleware stack in children
3723 return obj.Bug, nil
3724 })
3725 if err != nil {
3726 ec.Error(ctx, err)
3727 return graphql.Null
3728 }
3729 if resTmp == nil {
3730 if !graphql.HasFieldError(ctx, fc) {
3731 ec.Errorf(ctx, "must not be null")
3732 }
3733 return graphql.Null
3734 }
3735 res := resTmp.(models.BugWrapper)
3736 fc.Result = res
3737 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
3738}
3739
3740func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3741 defer func() {
3742 if r := recover(); r != nil {
3743 ec.Error(ctx, ec.Recover(ctx, r))
3744 ret = graphql.Null
3745 }
3746 }()
3747 fc := &graphql.FieldContext{
3748 Object: "AddCommentPayload",
3749 Field: field,
3750 Args: nil,
3751 IsMethod: false,
3752 IsResolver: false,
3753 }
3754
3755 ctx = graphql.WithFieldContext(ctx, fc)
3756 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3757 ctx = rctx // use context from middleware stack in children
3758 return obj.Operation, nil
3759 })
3760 if err != nil {
3761 ec.Error(ctx, err)
3762 return graphql.Null
3763 }
3764 if resTmp == nil {
3765 if !graphql.HasFieldError(ctx, fc) {
3766 ec.Errorf(ctx, "must not be null")
3767 }
3768 return graphql.Null
3769 }
3770 res := resTmp.(*bug.AddCommentOperation)
3771 fc.Result = res
3772 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3773}
3774
3775func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3776 defer func() {
3777 if r := recover(); r != nil {
3778 ec.Error(ctx, ec.Recover(ctx, r))
3779 ret = graphql.Null
3780 }
3781 }()
3782 fc := &graphql.FieldContext{
3783 Object: "AddCommentTimelineItem",
3784 Field: field,
3785 Args: nil,
3786 IsMethod: true,
3787 IsResolver: true,
3788 }
3789
3790 ctx = graphql.WithFieldContext(ctx, fc)
3791 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3792 ctx = rctx // use context from middleware stack in children
3793 return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
3794 })
3795 if err != nil {
3796 ec.Error(ctx, err)
3797 return graphql.Null
3798 }
3799 if resTmp == nil {
3800 if !graphql.HasFieldError(ctx, fc) {
3801 ec.Errorf(ctx, "must not be null")
3802 }
3803 return graphql.Null
3804 }
3805 res := resTmp.(string)
3806 fc.Result = res
3807 return ec.marshalNString2string(ctx, field.Selections, res)
3808}
3809
3810func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3811 defer func() {
3812 if r := recover(); r != nil {
3813 ec.Error(ctx, ec.Recover(ctx, r))
3814 ret = graphql.Null
3815 }
3816 }()
3817 fc := &graphql.FieldContext{
3818 Object: "AddCommentTimelineItem",
3819 Field: field,
3820 Args: nil,
3821 IsMethod: true,
3822 IsResolver: true,
3823 }
3824
3825 ctx = graphql.WithFieldContext(ctx, fc)
3826 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3827 ctx = rctx // use context from middleware stack in children
3828 return ec.resolvers.AddCommentTimelineItem().Author(rctx, obj)
3829 })
3830 if err != nil {
3831 ec.Error(ctx, err)
3832 return graphql.Null
3833 }
3834 if resTmp == nil {
3835 if !graphql.HasFieldError(ctx, fc) {
3836 ec.Errorf(ctx, "must not be null")
3837 }
3838 return graphql.Null
3839 }
3840 res := resTmp.(models.IdentityWrapper)
3841 fc.Result = res
3842 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3843}
3844
3845func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3846 defer func() {
3847 if r := recover(); r != nil {
3848 ec.Error(ctx, ec.Recover(ctx, r))
3849 ret = graphql.Null
3850 }
3851 }()
3852 fc := &graphql.FieldContext{
3853 Object: "AddCommentTimelineItem",
3854 Field: field,
3855 Args: nil,
3856 IsMethod: false,
3857 IsResolver: false,
3858 }
3859
3860 ctx = graphql.WithFieldContext(ctx, fc)
3861 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3862 ctx = rctx // use context from middleware stack in children
3863 return obj.Message, nil
3864 })
3865 if err != nil {
3866 ec.Error(ctx, err)
3867 return graphql.Null
3868 }
3869 if resTmp == nil {
3870 if !graphql.HasFieldError(ctx, fc) {
3871 ec.Errorf(ctx, "must not be null")
3872 }
3873 return graphql.Null
3874 }
3875 res := resTmp.(string)
3876 fc.Result = res
3877 return ec.marshalNString2string(ctx, field.Selections, res)
3878}
3879
3880func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3881 defer func() {
3882 if r := recover(); r != nil {
3883 ec.Error(ctx, ec.Recover(ctx, r))
3884 ret = graphql.Null
3885 }
3886 }()
3887 fc := &graphql.FieldContext{
3888 Object: "AddCommentTimelineItem",
3889 Field: field,
3890 Args: nil,
3891 IsMethod: true,
3892 IsResolver: false,
3893 }
3894
3895 ctx = graphql.WithFieldContext(ctx, fc)
3896 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3897 ctx = rctx // use context from middleware stack in children
3898 return obj.MessageIsEmpty(), nil
3899 })
3900 if err != nil {
3901 ec.Error(ctx, err)
3902 return graphql.Null
3903 }
3904 if resTmp == nil {
3905 if !graphql.HasFieldError(ctx, fc) {
3906 ec.Errorf(ctx, "must not be null")
3907 }
3908 return graphql.Null
3909 }
3910 res := resTmp.(bool)
3911 fc.Result = res
3912 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3913}
3914
3915func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3916 defer func() {
3917 if r := recover(); r != nil {
3918 ec.Error(ctx, ec.Recover(ctx, r))
3919 ret = graphql.Null
3920 }
3921 }()
3922 fc := &graphql.FieldContext{
3923 Object: "AddCommentTimelineItem",
3924 Field: field,
3925 Args: nil,
3926 IsMethod: false,
3927 IsResolver: false,
3928 }
3929
3930 ctx = graphql.WithFieldContext(ctx, fc)
3931 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3932 ctx = rctx // use context from middleware stack in children
3933 return obj.Files, nil
3934 })
3935 if err != nil {
3936 ec.Error(ctx, err)
3937 return graphql.Null
3938 }
3939 if resTmp == nil {
3940 if !graphql.HasFieldError(ctx, fc) {
3941 ec.Errorf(ctx, "must not be null")
3942 }
3943 return graphql.Null
3944 }
3945 res := resTmp.([]repository.Hash)
3946 fc.Result = res
3947 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
3948}
3949
3950func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3951 defer func() {
3952 if r := recover(); r != nil {
3953 ec.Error(ctx, ec.Recover(ctx, r))
3954 ret = graphql.Null
3955 }
3956 }()
3957 fc := &graphql.FieldContext{
3958 Object: "AddCommentTimelineItem",
3959 Field: field,
3960 Args: nil,
3961 IsMethod: true,
3962 IsResolver: true,
3963 }
3964
3965 ctx = graphql.WithFieldContext(ctx, fc)
3966 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3967 ctx = rctx // use context from middleware stack in children
3968 return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
3969 })
3970 if err != nil {
3971 ec.Error(ctx, err)
3972 return graphql.Null
3973 }
3974 if resTmp == nil {
3975 if !graphql.HasFieldError(ctx, fc) {
3976 ec.Errorf(ctx, "must not be null")
3977 }
3978 return graphql.Null
3979 }
3980 res := resTmp.(*time.Time)
3981 fc.Result = res
3982 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3983}
3984
3985func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3986 defer func() {
3987 if r := recover(); r != nil {
3988 ec.Error(ctx, ec.Recover(ctx, r))
3989 ret = graphql.Null
3990 }
3991 }()
3992 fc := &graphql.FieldContext{
3993 Object: "AddCommentTimelineItem",
3994 Field: field,
3995 Args: nil,
3996 IsMethod: true,
3997 IsResolver: true,
3998 }
3999
4000 ctx = graphql.WithFieldContext(ctx, fc)
4001 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4002 ctx = rctx // use context from middleware stack in children
4003 return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
4004 })
4005 if err != nil {
4006 ec.Error(ctx, err)
4007 return graphql.Null
4008 }
4009 if resTmp == nil {
4010 if !graphql.HasFieldError(ctx, fc) {
4011 ec.Errorf(ctx, "must not be null")
4012 }
4013 return graphql.Null
4014 }
4015 res := resTmp.(*time.Time)
4016 fc.Result = res
4017 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
4018}
4019
4020func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
4021 defer func() {
4022 if r := recover(); r != nil {
4023 ec.Error(ctx, ec.Recover(ctx, r))
4024 ret = graphql.Null
4025 }
4026 }()
4027 fc := &graphql.FieldContext{
4028 Object: "AddCommentTimelineItem",
4029 Field: field,
4030 Args: nil,
4031 IsMethod: true,
4032 IsResolver: false,
4033 }
4034
4035 ctx = graphql.WithFieldContext(ctx, fc)
4036 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4037 ctx = rctx // use context from middleware stack in children
4038 return obj.Edited(), nil
4039 })
4040 if err != nil {
4041 ec.Error(ctx, err)
4042 return graphql.Null
4043 }
4044 if resTmp == nil {
4045 if !graphql.HasFieldError(ctx, fc) {
4046 ec.Errorf(ctx, "must not be null")
4047 }
4048 return graphql.Null
4049 }
4050 res := resTmp.(bool)
4051 fc.Result = res
4052 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
4053}
4054
4055func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
4056 defer func() {
4057 if r := recover(); r != nil {
4058 ec.Error(ctx, ec.Recover(ctx, r))
4059 ret = graphql.Null
4060 }
4061 }()
4062 fc := &graphql.FieldContext{
4063 Object: "AddCommentTimelineItem",
4064 Field: field,
4065 Args: nil,
4066 IsMethod: false,
4067 IsResolver: false,
4068 }
4069
4070 ctx = graphql.WithFieldContext(ctx, fc)
4071 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4072 ctx = rctx // use context from middleware stack in children
4073 return obj.History, nil
4074 })
4075 if err != nil {
4076 ec.Error(ctx, err)
4077 return graphql.Null
4078 }
4079 if resTmp == nil {
4080 if !graphql.HasFieldError(ctx, fc) {
4081 ec.Errorf(ctx, "must not be null")
4082 }
4083 return graphql.Null
4084 }
4085 res := resTmp.([]bug.CommentHistoryStep)
4086 fc.Result = res
4087 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
4088}
4089
4090func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4091 defer func() {
4092 if r := recover(); r != nil {
4093 ec.Error(ctx, ec.Recover(ctx, r))
4094 ret = graphql.Null
4095 }
4096 }()
4097 fc := &graphql.FieldContext{
4098 Object: "Bug",
4099 Field: field,
4100 Args: nil,
4101 IsMethod: true,
4102 IsResolver: true,
4103 }
4104
4105 ctx = graphql.WithFieldContext(ctx, fc)
4106 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4107 ctx = rctx // use context from middleware stack in children
4108 return ec.resolvers.Bug().ID(rctx, obj)
4109 })
4110 if err != nil {
4111 ec.Error(ctx, err)
4112 return graphql.Null
4113 }
4114 if resTmp == nil {
4115 if !graphql.HasFieldError(ctx, fc) {
4116 ec.Errorf(ctx, "must not be null")
4117 }
4118 return graphql.Null
4119 }
4120 res := resTmp.(string)
4121 fc.Result = res
4122 return ec.marshalNString2string(ctx, field.Selections, res)
4123}
4124
4125func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4126 defer func() {
4127 if r := recover(); r != nil {
4128 ec.Error(ctx, ec.Recover(ctx, r))
4129 ret = graphql.Null
4130 }
4131 }()
4132 fc := &graphql.FieldContext{
4133 Object: "Bug",
4134 Field: field,
4135 Args: nil,
4136 IsMethod: true,
4137 IsResolver: true,
4138 }
4139
4140 ctx = graphql.WithFieldContext(ctx, fc)
4141 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4142 ctx = rctx // use context from middleware stack in children
4143 return ec.resolvers.Bug().HumanID(rctx, obj)
4144 })
4145 if err != nil {
4146 ec.Error(ctx, err)
4147 return graphql.Null
4148 }
4149 if resTmp == nil {
4150 if !graphql.HasFieldError(ctx, fc) {
4151 ec.Errorf(ctx, "must not be null")
4152 }
4153 return graphql.Null
4154 }
4155 res := resTmp.(string)
4156 fc.Result = res
4157 return ec.marshalNString2string(ctx, field.Selections, res)
4158}
4159
4160func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4161 defer func() {
4162 if r := recover(); r != nil {
4163 ec.Error(ctx, ec.Recover(ctx, r))
4164 ret = graphql.Null
4165 }
4166 }()
4167 fc := &graphql.FieldContext{
4168 Object: "Bug",
4169 Field: field,
4170 Args: nil,
4171 IsMethod: true,
4172 IsResolver: true,
4173 }
4174
4175 ctx = graphql.WithFieldContext(ctx, fc)
4176 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4177 ctx = rctx // use context from middleware stack in children
4178 return ec.resolvers.Bug().Status(rctx, obj)
4179 })
4180 if err != nil {
4181 ec.Error(ctx, err)
4182 return graphql.Null
4183 }
4184 if resTmp == nil {
4185 if !graphql.HasFieldError(ctx, fc) {
4186 ec.Errorf(ctx, "must not be null")
4187 }
4188 return graphql.Null
4189 }
4190 res := resTmp.(models.Status)
4191 fc.Result = res
4192 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
4193}
4194
4195func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4196 defer func() {
4197 if r := recover(); r != nil {
4198 ec.Error(ctx, ec.Recover(ctx, r))
4199 ret = graphql.Null
4200 }
4201 }()
4202 fc := &graphql.FieldContext{
4203 Object: "Bug",
4204 Field: field,
4205 Args: nil,
4206 IsMethod: true,
4207 IsResolver: false,
4208 }
4209
4210 ctx = graphql.WithFieldContext(ctx, fc)
4211 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4212 ctx = rctx // use context from middleware stack in children
4213 return obj.Title(), nil
4214 })
4215 if err != nil {
4216 ec.Error(ctx, err)
4217 return graphql.Null
4218 }
4219 if resTmp == nil {
4220 if !graphql.HasFieldError(ctx, fc) {
4221 ec.Errorf(ctx, "must not be null")
4222 }
4223 return graphql.Null
4224 }
4225 res := resTmp.(string)
4226 fc.Result = res
4227 return ec.marshalNString2string(ctx, field.Selections, res)
4228}
4229
4230func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4231 defer func() {
4232 if r := recover(); r != nil {
4233 ec.Error(ctx, ec.Recover(ctx, r))
4234 ret = graphql.Null
4235 }
4236 }()
4237 fc := &graphql.FieldContext{
4238 Object: "Bug",
4239 Field: field,
4240 Args: nil,
4241 IsMethod: true,
4242 IsResolver: false,
4243 }
4244
4245 ctx = graphql.WithFieldContext(ctx, fc)
4246 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4247 ctx = rctx // use context from middleware stack in children
4248 return obj.Labels(), nil
4249 })
4250 if err != nil {
4251 ec.Error(ctx, err)
4252 return graphql.Null
4253 }
4254 if resTmp == nil {
4255 if !graphql.HasFieldError(ctx, fc) {
4256 ec.Errorf(ctx, "must not be null")
4257 }
4258 return graphql.Null
4259 }
4260 res := resTmp.([]bug.Label)
4261 fc.Result = res
4262 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
4263}
4264
4265func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4266 defer func() {
4267 if r := recover(); r != nil {
4268 ec.Error(ctx, ec.Recover(ctx, r))
4269 ret = graphql.Null
4270 }
4271 }()
4272 fc := &graphql.FieldContext{
4273 Object: "Bug",
4274 Field: field,
4275 Args: nil,
4276 IsMethod: true,
4277 IsResolver: false,
4278 }
4279
4280 ctx = graphql.WithFieldContext(ctx, fc)
4281 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4282 ctx = rctx // use context from middleware stack in children
4283 return obj.Author()
4284 })
4285 if err != nil {
4286 ec.Error(ctx, err)
4287 return graphql.Null
4288 }
4289 if resTmp == nil {
4290 if !graphql.HasFieldError(ctx, fc) {
4291 ec.Errorf(ctx, "must not be null")
4292 }
4293 return graphql.Null
4294 }
4295 res := resTmp.(models.IdentityWrapper)
4296 fc.Result = res
4297 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
4298}
4299
4300func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4301 defer func() {
4302 if r := recover(); r != nil {
4303 ec.Error(ctx, ec.Recover(ctx, r))
4304 ret = graphql.Null
4305 }
4306 }()
4307 fc := &graphql.FieldContext{
4308 Object: "Bug",
4309 Field: field,
4310 Args: nil,
4311 IsMethod: true,
4312 IsResolver: false,
4313 }
4314
4315 ctx = graphql.WithFieldContext(ctx, fc)
4316 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4317 ctx = rctx // use context from middleware stack in children
4318 return obj.CreatedAt(), nil
4319 })
4320 if err != nil {
4321 ec.Error(ctx, err)
4322 return graphql.Null
4323 }
4324 if resTmp == nil {
4325 if !graphql.HasFieldError(ctx, fc) {
4326 ec.Errorf(ctx, "must not be null")
4327 }
4328 return graphql.Null
4329 }
4330 res := resTmp.(time.Time)
4331 fc.Result = res
4332 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
4333}
4334
4335func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4336 defer func() {
4337 if r := recover(); r != nil {
4338 ec.Error(ctx, ec.Recover(ctx, r))
4339 ret = graphql.Null
4340 }
4341 }()
4342 fc := &graphql.FieldContext{
4343 Object: "Bug",
4344 Field: field,
4345 Args: nil,
4346 IsMethod: true,
4347 IsResolver: false,
4348 }
4349
4350 ctx = graphql.WithFieldContext(ctx, fc)
4351 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4352 ctx = rctx // use context from middleware stack in children
4353 return obj.LastEdit(), nil
4354 })
4355 if err != nil {
4356 ec.Error(ctx, err)
4357 return graphql.Null
4358 }
4359 if resTmp == nil {
4360 if !graphql.HasFieldError(ctx, fc) {
4361 ec.Errorf(ctx, "must not be null")
4362 }
4363 return graphql.Null
4364 }
4365 res := resTmp.(time.Time)
4366 fc.Result = res
4367 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
4368}
4369
4370func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4371 defer func() {
4372 if r := recover(); r != nil {
4373 ec.Error(ctx, ec.Recover(ctx, r))
4374 ret = graphql.Null
4375 }
4376 }()
4377 fc := &graphql.FieldContext{
4378 Object: "Bug",
4379 Field: field,
4380 Args: nil,
4381 IsMethod: true,
4382 IsResolver: true,
4383 }
4384
4385 ctx = graphql.WithFieldContext(ctx, fc)
4386 rawArgs := field.ArgumentMap(ec.Variables)
4387 args, err := ec.field_Bug_actors_args(ctx, rawArgs)
4388 if err != nil {
4389 ec.Error(ctx, err)
4390 return graphql.Null
4391 }
4392 fc.Args = args
4393 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4394 ctx = rctx // use context from middleware stack in children
4395 return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4396 })
4397 if err != nil {
4398 ec.Error(ctx, err)
4399 return graphql.Null
4400 }
4401 if resTmp == nil {
4402 if !graphql.HasFieldError(ctx, fc) {
4403 ec.Errorf(ctx, "must not be null")
4404 }
4405 return graphql.Null
4406 }
4407 res := resTmp.(*models.IdentityConnection)
4408 fc.Result = res
4409 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4410}
4411
4412func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4413 defer func() {
4414 if r := recover(); r != nil {
4415 ec.Error(ctx, ec.Recover(ctx, r))
4416 ret = graphql.Null
4417 }
4418 }()
4419 fc := &graphql.FieldContext{
4420 Object: "Bug",
4421 Field: field,
4422 Args: nil,
4423 IsMethod: true,
4424 IsResolver: true,
4425 }
4426
4427 ctx = graphql.WithFieldContext(ctx, fc)
4428 rawArgs := field.ArgumentMap(ec.Variables)
4429 args, err := ec.field_Bug_participants_args(ctx, rawArgs)
4430 if err != nil {
4431 ec.Error(ctx, err)
4432 return graphql.Null
4433 }
4434 fc.Args = args
4435 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4436 ctx = rctx // use context from middleware stack in children
4437 return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4438 })
4439 if err != nil {
4440 ec.Error(ctx, err)
4441 return graphql.Null
4442 }
4443 if resTmp == nil {
4444 if !graphql.HasFieldError(ctx, fc) {
4445 ec.Errorf(ctx, "must not be null")
4446 }
4447 return graphql.Null
4448 }
4449 res := resTmp.(*models.IdentityConnection)
4450 fc.Result = res
4451 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4452}
4453
4454func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4455 defer func() {
4456 if r := recover(); r != nil {
4457 ec.Error(ctx, ec.Recover(ctx, r))
4458 ret = graphql.Null
4459 }
4460 }()
4461 fc := &graphql.FieldContext{
4462 Object: "Bug",
4463 Field: field,
4464 Args: nil,
4465 IsMethod: true,
4466 IsResolver: true,
4467 }
4468
4469 ctx = graphql.WithFieldContext(ctx, fc)
4470 rawArgs := field.ArgumentMap(ec.Variables)
4471 args, err := ec.field_Bug_comments_args(ctx, rawArgs)
4472 if err != nil {
4473 ec.Error(ctx, err)
4474 return graphql.Null
4475 }
4476 fc.Args = args
4477 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4478 ctx = rctx // use context from middleware stack in children
4479 return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4480 })
4481 if err != nil {
4482 ec.Error(ctx, err)
4483 return graphql.Null
4484 }
4485 if resTmp == nil {
4486 if !graphql.HasFieldError(ctx, fc) {
4487 ec.Errorf(ctx, "must not be null")
4488 }
4489 return graphql.Null
4490 }
4491 res := resTmp.(*models.CommentConnection)
4492 fc.Result = res
4493 return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
4494}
4495
4496func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4497 defer func() {
4498 if r := recover(); r != nil {
4499 ec.Error(ctx, ec.Recover(ctx, r))
4500 ret = graphql.Null
4501 }
4502 }()
4503 fc := &graphql.FieldContext{
4504 Object: "Bug",
4505 Field: field,
4506 Args: nil,
4507 IsMethod: true,
4508 IsResolver: true,
4509 }
4510
4511 ctx = graphql.WithFieldContext(ctx, fc)
4512 rawArgs := field.ArgumentMap(ec.Variables)
4513 args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
4514 if err != nil {
4515 ec.Error(ctx, err)
4516 return graphql.Null
4517 }
4518 fc.Args = args
4519 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4520 ctx = rctx // use context from middleware stack in children
4521 return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4522 })
4523 if err != nil {
4524 ec.Error(ctx, err)
4525 return graphql.Null
4526 }
4527 if resTmp == nil {
4528 if !graphql.HasFieldError(ctx, fc) {
4529 ec.Errorf(ctx, "must not be null")
4530 }
4531 return graphql.Null
4532 }
4533 res := resTmp.(*models.TimelineItemConnection)
4534 fc.Result = res
4535 return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
4536}
4537
4538func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4539 defer func() {
4540 if r := recover(); r != nil {
4541 ec.Error(ctx, ec.Recover(ctx, r))
4542 ret = graphql.Null
4543 }
4544 }()
4545 fc := &graphql.FieldContext{
4546 Object: "Bug",
4547 Field: field,
4548 Args: nil,
4549 IsMethod: true,
4550 IsResolver: true,
4551 }
4552
4553 ctx = graphql.WithFieldContext(ctx, fc)
4554 rawArgs := field.ArgumentMap(ec.Variables)
4555 args, err := ec.field_Bug_operations_args(ctx, rawArgs)
4556 if err != nil {
4557 ec.Error(ctx, err)
4558 return graphql.Null
4559 }
4560 fc.Args = args
4561 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4562 ctx = rctx // use context from middleware stack in children
4563 return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4564 })
4565 if err != nil {
4566 ec.Error(ctx, err)
4567 return graphql.Null
4568 }
4569 if resTmp == nil {
4570 if !graphql.HasFieldError(ctx, fc) {
4571 ec.Errorf(ctx, "must not be null")
4572 }
4573 return graphql.Null
4574 }
4575 res := resTmp.(*models.OperationConnection)
4576 fc.Result = res
4577 return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
4578}
4579
4580func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4581 defer func() {
4582 if r := recover(); r != nil {
4583 ec.Error(ctx, ec.Recover(ctx, r))
4584 ret = graphql.Null
4585 }
4586 }()
4587 fc := &graphql.FieldContext{
4588 Object: "BugConnection",
4589 Field: field,
4590 Args: nil,
4591 IsMethod: false,
4592 IsResolver: false,
4593 }
4594
4595 ctx = graphql.WithFieldContext(ctx, fc)
4596 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4597 ctx = rctx // use context from middleware stack in children
4598 return obj.Edges, nil
4599 })
4600 if err != nil {
4601 ec.Error(ctx, err)
4602 return graphql.Null
4603 }
4604 if resTmp == nil {
4605 if !graphql.HasFieldError(ctx, fc) {
4606 ec.Errorf(ctx, "must not be null")
4607 }
4608 return graphql.Null
4609 }
4610 res := resTmp.([]*models.BugEdge)
4611 fc.Result = res
4612 return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
4613}
4614
4615func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4616 defer func() {
4617 if r := recover(); r != nil {
4618 ec.Error(ctx, ec.Recover(ctx, r))
4619 ret = graphql.Null
4620 }
4621 }()
4622 fc := &graphql.FieldContext{
4623 Object: "BugConnection",
4624 Field: field,
4625 Args: nil,
4626 IsMethod: false,
4627 IsResolver: false,
4628 }
4629
4630 ctx = graphql.WithFieldContext(ctx, fc)
4631 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4632 ctx = rctx // use context from middleware stack in children
4633 return obj.Nodes, nil
4634 })
4635 if err != nil {
4636 ec.Error(ctx, err)
4637 return graphql.Null
4638 }
4639 if resTmp == nil {
4640 if !graphql.HasFieldError(ctx, fc) {
4641 ec.Errorf(ctx, "must not be null")
4642 }
4643 return graphql.Null
4644 }
4645 res := resTmp.([]models.BugWrapper)
4646 fc.Result = res
4647 return ec.marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx, field.Selections, res)
4648}
4649
4650func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4651 defer func() {
4652 if r := recover(); r != nil {
4653 ec.Error(ctx, ec.Recover(ctx, r))
4654 ret = graphql.Null
4655 }
4656 }()
4657 fc := &graphql.FieldContext{
4658 Object: "BugConnection",
4659 Field: field,
4660 Args: nil,
4661 IsMethod: false,
4662 IsResolver: false,
4663 }
4664
4665 ctx = graphql.WithFieldContext(ctx, fc)
4666 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4667 ctx = rctx // use context from middleware stack in children
4668 return obj.PageInfo, nil
4669 })
4670 if err != nil {
4671 ec.Error(ctx, err)
4672 return graphql.Null
4673 }
4674 if resTmp == nil {
4675 if !graphql.HasFieldError(ctx, fc) {
4676 ec.Errorf(ctx, "must not be null")
4677 }
4678 return graphql.Null
4679 }
4680 res := resTmp.(*models.PageInfo)
4681 fc.Result = res
4682 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
4683}
4684
4685func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4686 defer func() {
4687 if r := recover(); r != nil {
4688 ec.Error(ctx, ec.Recover(ctx, r))
4689 ret = graphql.Null
4690 }
4691 }()
4692 fc := &graphql.FieldContext{
4693 Object: "BugConnection",
4694 Field: field,
4695 Args: nil,
4696 IsMethod: false,
4697 IsResolver: false,
4698 }
4699
4700 ctx = graphql.WithFieldContext(ctx, fc)
4701 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4702 ctx = rctx // use context from middleware stack in children
4703 return obj.TotalCount, nil
4704 })
4705 if err != nil {
4706 ec.Error(ctx, err)
4707 return graphql.Null
4708 }
4709 if resTmp == nil {
4710 if !graphql.HasFieldError(ctx, fc) {
4711 ec.Errorf(ctx, "must not be null")
4712 }
4713 return graphql.Null
4714 }
4715 res := resTmp.(int)
4716 fc.Result = res
4717 return ec.marshalNInt2int(ctx, field.Selections, res)
4718}
4719
4720func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4721 defer func() {
4722 if r := recover(); r != nil {
4723 ec.Error(ctx, ec.Recover(ctx, r))
4724 ret = graphql.Null
4725 }
4726 }()
4727 fc := &graphql.FieldContext{
4728 Object: "BugEdge",
4729 Field: field,
4730 Args: nil,
4731 IsMethod: false,
4732 IsResolver: false,
4733 }
4734
4735 ctx = graphql.WithFieldContext(ctx, fc)
4736 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4737 ctx = rctx // use context from middleware stack in children
4738 return obj.Cursor, nil
4739 })
4740 if err != nil {
4741 ec.Error(ctx, err)
4742 return graphql.Null
4743 }
4744 if resTmp == nil {
4745 if !graphql.HasFieldError(ctx, fc) {
4746 ec.Errorf(ctx, "must not be null")
4747 }
4748 return graphql.Null
4749 }
4750 res := resTmp.(string)
4751 fc.Result = res
4752 return ec.marshalNString2string(ctx, field.Selections, res)
4753}
4754
4755func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4756 defer func() {
4757 if r := recover(); r != nil {
4758 ec.Error(ctx, ec.Recover(ctx, r))
4759 ret = graphql.Null
4760 }
4761 }()
4762 fc := &graphql.FieldContext{
4763 Object: "BugEdge",
4764 Field: field,
4765 Args: nil,
4766 IsMethod: false,
4767 IsResolver: false,
4768 }
4769
4770 ctx = graphql.WithFieldContext(ctx, fc)
4771 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4772 ctx = rctx // use context from middleware stack in children
4773 return obj.Node, nil
4774 })
4775 if err != nil {
4776 ec.Error(ctx, err)
4777 return graphql.Null
4778 }
4779 if resTmp == nil {
4780 if !graphql.HasFieldError(ctx, fc) {
4781 ec.Errorf(ctx, "must not be null")
4782 }
4783 return graphql.Null
4784 }
4785 res := resTmp.(models.BugWrapper)
4786 fc.Result = res
4787 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4788}
4789
4790func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4791 defer func() {
4792 if r := recover(); r != nil {
4793 ec.Error(ctx, ec.Recover(ctx, r))
4794 ret = graphql.Null
4795 }
4796 }()
4797 fc := &graphql.FieldContext{
4798 Object: "ChangeLabelPayload",
4799 Field: field,
4800 Args: nil,
4801 IsMethod: false,
4802 IsResolver: false,
4803 }
4804
4805 ctx = graphql.WithFieldContext(ctx, fc)
4806 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4807 ctx = rctx // use context from middleware stack in children
4808 return obj.ClientMutationID, nil
4809 })
4810 if err != nil {
4811 ec.Error(ctx, err)
4812 return graphql.Null
4813 }
4814 if resTmp == nil {
4815 return graphql.Null
4816 }
4817 res := resTmp.(*string)
4818 fc.Result = res
4819 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4820}
4821
4822func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4823 defer func() {
4824 if r := recover(); r != nil {
4825 ec.Error(ctx, ec.Recover(ctx, r))
4826 ret = graphql.Null
4827 }
4828 }()
4829 fc := &graphql.FieldContext{
4830 Object: "ChangeLabelPayload",
4831 Field: field,
4832 Args: nil,
4833 IsMethod: false,
4834 IsResolver: false,
4835 }
4836
4837 ctx = graphql.WithFieldContext(ctx, fc)
4838 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4839 ctx = rctx // use context from middleware stack in children
4840 return obj.Bug, nil
4841 })
4842 if err != nil {
4843 ec.Error(ctx, err)
4844 return graphql.Null
4845 }
4846 if resTmp == nil {
4847 if !graphql.HasFieldError(ctx, fc) {
4848 ec.Errorf(ctx, "must not be null")
4849 }
4850 return graphql.Null
4851 }
4852 res := resTmp.(models.BugWrapper)
4853 fc.Result = res
4854 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4855}
4856
4857func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4858 defer func() {
4859 if r := recover(); r != nil {
4860 ec.Error(ctx, ec.Recover(ctx, r))
4861 ret = graphql.Null
4862 }
4863 }()
4864 fc := &graphql.FieldContext{
4865 Object: "ChangeLabelPayload",
4866 Field: field,
4867 Args: nil,
4868 IsMethod: false,
4869 IsResolver: false,
4870 }
4871
4872 ctx = graphql.WithFieldContext(ctx, fc)
4873 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4874 ctx = rctx // use context from middleware stack in children
4875 return obj.Operation, nil
4876 })
4877 if err != nil {
4878 ec.Error(ctx, err)
4879 return graphql.Null
4880 }
4881 if resTmp == nil {
4882 if !graphql.HasFieldError(ctx, fc) {
4883 ec.Errorf(ctx, "must not be null")
4884 }
4885 return graphql.Null
4886 }
4887 res := resTmp.(*bug.LabelChangeOperation)
4888 fc.Result = res
4889 return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
4890}
4891
4892func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4893 defer func() {
4894 if r := recover(); r != nil {
4895 ec.Error(ctx, ec.Recover(ctx, r))
4896 ret = graphql.Null
4897 }
4898 }()
4899 fc := &graphql.FieldContext{
4900 Object: "ChangeLabelPayload",
4901 Field: field,
4902 Args: nil,
4903 IsMethod: false,
4904 IsResolver: false,
4905 }
4906
4907 ctx = graphql.WithFieldContext(ctx, fc)
4908 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4909 ctx = rctx // use context from middleware stack in children
4910 return obj.Results, nil
4911 })
4912 if err != nil {
4913 ec.Error(ctx, err)
4914 return graphql.Null
4915 }
4916 if resTmp == nil {
4917 if !graphql.HasFieldError(ctx, fc) {
4918 ec.Errorf(ctx, "must not be null")
4919 }
4920 return graphql.Null
4921 }
4922 res := resTmp.([]*bug.LabelChangeResult)
4923 fc.Result = res
4924 return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
4925}
4926
4927func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4928 defer func() {
4929 if r := recover(); r != nil {
4930 ec.Error(ctx, ec.Recover(ctx, r))
4931 ret = graphql.Null
4932 }
4933 }()
4934 fc := &graphql.FieldContext{
4935 Object: "CloseBugPayload",
4936 Field: field,
4937 Args: nil,
4938 IsMethod: false,
4939 IsResolver: false,
4940 }
4941
4942 ctx = graphql.WithFieldContext(ctx, fc)
4943 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4944 ctx = rctx // use context from middleware stack in children
4945 return obj.ClientMutationID, nil
4946 })
4947 if err != nil {
4948 ec.Error(ctx, err)
4949 return graphql.Null
4950 }
4951 if resTmp == nil {
4952 return graphql.Null
4953 }
4954 res := resTmp.(*string)
4955 fc.Result = res
4956 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4957}
4958
4959func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4960 defer func() {
4961 if r := recover(); r != nil {
4962 ec.Error(ctx, ec.Recover(ctx, r))
4963 ret = graphql.Null
4964 }
4965 }()
4966 fc := &graphql.FieldContext{
4967 Object: "CloseBugPayload",
4968 Field: field,
4969 Args: nil,
4970 IsMethod: false,
4971 IsResolver: false,
4972 }
4973
4974 ctx = graphql.WithFieldContext(ctx, fc)
4975 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4976 ctx = rctx // use context from middleware stack in children
4977 return obj.Bug, nil
4978 })
4979 if err != nil {
4980 ec.Error(ctx, err)
4981 return graphql.Null
4982 }
4983 if resTmp == nil {
4984 if !graphql.HasFieldError(ctx, fc) {
4985 ec.Errorf(ctx, "must not be null")
4986 }
4987 return graphql.Null
4988 }
4989 res := resTmp.(models.BugWrapper)
4990 fc.Result = res
4991 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4992}
4993
4994func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4995 defer func() {
4996 if r := recover(); r != nil {
4997 ec.Error(ctx, ec.Recover(ctx, r))
4998 ret = graphql.Null
4999 }
5000 }()
5001 fc := &graphql.FieldContext{
5002 Object: "CloseBugPayload",
5003 Field: field,
5004 Args: nil,
5005 IsMethod: false,
5006 IsResolver: false,
5007 }
5008
5009 ctx = graphql.WithFieldContext(ctx, fc)
5010 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5011 ctx = rctx // use context from middleware stack in children
5012 return obj.Operation, nil
5013 })
5014 if err != nil {
5015 ec.Error(ctx, err)
5016 return graphql.Null
5017 }
5018 if resTmp == nil {
5019 if !graphql.HasFieldError(ctx, fc) {
5020 ec.Errorf(ctx, "must not be null")
5021 }
5022 return graphql.Null
5023 }
5024 res := resTmp.(*bug.SetStatusOperation)
5025 fc.Result = res
5026 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
5027}
5028
5029func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
5030 defer func() {
5031 if r := recover(); r != nil {
5032 ec.Error(ctx, ec.Recover(ctx, r))
5033 ret = graphql.Null
5034 }
5035 }()
5036 fc := &graphql.FieldContext{
5037 Object: "Color",
5038 Field: field,
5039 Args: nil,
5040 IsMethod: true,
5041 IsResolver: true,
5042 }
5043
5044 ctx = graphql.WithFieldContext(ctx, fc)
5045 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5046 ctx = rctx // use context from middleware stack in children
5047 return ec.resolvers.Color().R(rctx, obj)
5048 })
5049 if err != nil {
5050 ec.Error(ctx, err)
5051 return graphql.Null
5052 }
5053 if resTmp == nil {
5054 if !graphql.HasFieldError(ctx, fc) {
5055 ec.Errorf(ctx, "must not be null")
5056 }
5057 return graphql.Null
5058 }
5059 res := resTmp.(int)
5060 fc.Result = res
5061 return ec.marshalNInt2int(ctx, field.Selections, res)
5062}
5063
5064func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
5065 defer func() {
5066 if r := recover(); r != nil {
5067 ec.Error(ctx, ec.Recover(ctx, r))
5068 ret = graphql.Null
5069 }
5070 }()
5071 fc := &graphql.FieldContext{
5072 Object: "Color",
5073 Field: field,
5074 Args: nil,
5075 IsMethod: true,
5076 IsResolver: true,
5077 }
5078
5079 ctx = graphql.WithFieldContext(ctx, fc)
5080 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5081 ctx = rctx // use context from middleware stack in children
5082 return ec.resolvers.Color().G(rctx, obj)
5083 })
5084 if err != nil {
5085 ec.Error(ctx, err)
5086 return graphql.Null
5087 }
5088 if resTmp == nil {
5089 if !graphql.HasFieldError(ctx, fc) {
5090 ec.Errorf(ctx, "must not be null")
5091 }
5092 return graphql.Null
5093 }
5094 res := resTmp.(int)
5095 fc.Result = res
5096 return ec.marshalNInt2int(ctx, field.Selections, res)
5097}
5098
5099func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
5100 defer func() {
5101 if r := recover(); r != nil {
5102 ec.Error(ctx, ec.Recover(ctx, r))
5103 ret = graphql.Null
5104 }
5105 }()
5106 fc := &graphql.FieldContext{
5107 Object: "Color",
5108 Field: field,
5109 Args: nil,
5110 IsMethod: true,
5111 IsResolver: true,
5112 }
5113
5114 ctx = graphql.WithFieldContext(ctx, fc)
5115 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5116 ctx = rctx // use context from middleware stack in children
5117 return ec.resolvers.Color().B(rctx, obj)
5118 })
5119 if err != nil {
5120 ec.Error(ctx, err)
5121 return graphql.Null
5122 }
5123 if resTmp == nil {
5124 if !graphql.HasFieldError(ctx, fc) {
5125 ec.Errorf(ctx, "must not be null")
5126 }
5127 return graphql.Null
5128 }
5129 res := resTmp.(int)
5130 fc.Result = res
5131 return ec.marshalNInt2int(ctx, field.Selections, res)
5132}
5133
5134func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
5135 defer func() {
5136 if r := recover(); r != nil {
5137 ec.Error(ctx, ec.Recover(ctx, r))
5138 ret = graphql.Null
5139 }
5140 }()
5141 fc := &graphql.FieldContext{
5142 Object: "Comment",
5143 Field: field,
5144 Args: nil,
5145 IsMethod: true,
5146 IsResolver: true,
5147 }
5148
5149 ctx = graphql.WithFieldContext(ctx, fc)
5150 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5151 ctx = rctx // use context from middleware stack in children
5152 return ec.resolvers.Comment().Author(rctx, obj)
5153 })
5154 if err != nil {
5155 ec.Error(ctx, err)
5156 return graphql.Null
5157 }
5158 if resTmp == nil {
5159 if !graphql.HasFieldError(ctx, fc) {
5160 ec.Errorf(ctx, "must not be null")
5161 }
5162 return graphql.Null
5163 }
5164 res := resTmp.(models.IdentityWrapper)
5165 fc.Result = res
5166 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5167}
5168
5169func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
5170 defer func() {
5171 if r := recover(); r != nil {
5172 ec.Error(ctx, ec.Recover(ctx, r))
5173 ret = graphql.Null
5174 }
5175 }()
5176 fc := &graphql.FieldContext{
5177 Object: "Comment",
5178 Field: field,
5179 Args: nil,
5180 IsMethod: false,
5181 IsResolver: false,
5182 }
5183
5184 ctx = graphql.WithFieldContext(ctx, fc)
5185 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5186 ctx = rctx // use context from middleware stack in children
5187 return obj.Message, nil
5188 })
5189 if err != nil {
5190 ec.Error(ctx, err)
5191 return graphql.Null
5192 }
5193 if resTmp == nil {
5194 if !graphql.HasFieldError(ctx, fc) {
5195 ec.Errorf(ctx, "must not be null")
5196 }
5197 return graphql.Null
5198 }
5199 res := resTmp.(string)
5200 fc.Result = res
5201 return ec.marshalNString2string(ctx, field.Selections, res)
5202}
5203
5204func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
5205 defer func() {
5206 if r := recover(); r != nil {
5207 ec.Error(ctx, ec.Recover(ctx, r))
5208 ret = graphql.Null
5209 }
5210 }()
5211 fc := &graphql.FieldContext{
5212 Object: "Comment",
5213 Field: field,
5214 Args: nil,
5215 IsMethod: false,
5216 IsResolver: false,
5217 }
5218
5219 ctx = graphql.WithFieldContext(ctx, fc)
5220 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5221 ctx = rctx // use context from middleware stack in children
5222 return obj.Files, nil
5223 })
5224 if err != nil {
5225 ec.Error(ctx, err)
5226 return graphql.Null
5227 }
5228 if resTmp == nil {
5229 if !graphql.HasFieldError(ctx, fc) {
5230 ec.Errorf(ctx, "must not be null")
5231 }
5232 return graphql.Null
5233 }
5234 res := resTmp.([]repository.Hash)
5235 fc.Result = res
5236 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
5237}
5238
5239func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
5240 defer func() {
5241 if r := recover(); r != nil {
5242 ec.Error(ctx, ec.Recover(ctx, r))
5243 ret = graphql.Null
5244 }
5245 }()
5246 fc := &graphql.FieldContext{
5247 Object: "CommentConnection",
5248 Field: field,
5249 Args: nil,
5250 IsMethod: false,
5251 IsResolver: false,
5252 }
5253
5254 ctx = graphql.WithFieldContext(ctx, fc)
5255 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5256 ctx = rctx // use context from middleware stack in children
5257 return obj.Edges, nil
5258 })
5259 if err != nil {
5260 ec.Error(ctx, err)
5261 return graphql.Null
5262 }
5263 if resTmp == nil {
5264 if !graphql.HasFieldError(ctx, fc) {
5265 ec.Errorf(ctx, "must not be null")
5266 }
5267 return graphql.Null
5268 }
5269 res := resTmp.([]*models.CommentEdge)
5270 fc.Result = res
5271 return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
5272}
5273
5274func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
5275 defer func() {
5276 if r := recover(); r != nil {
5277 ec.Error(ctx, ec.Recover(ctx, r))
5278 ret = graphql.Null
5279 }
5280 }()
5281 fc := &graphql.FieldContext{
5282 Object: "CommentConnection",
5283 Field: field,
5284 Args: nil,
5285 IsMethod: false,
5286 IsResolver: false,
5287 }
5288
5289 ctx = graphql.WithFieldContext(ctx, fc)
5290 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5291 ctx = rctx // use context from middleware stack in children
5292 return obj.Nodes, nil
5293 })
5294 if err != nil {
5295 ec.Error(ctx, err)
5296 return graphql.Null
5297 }
5298 if resTmp == nil {
5299 if !graphql.HasFieldError(ctx, fc) {
5300 ec.Errorf(ctx, "must not be null")
5301 }
5302 return graphql.Null
5303 }
5304 res := resTmp.([]*bug.Comment)
5305 fc.Result = res
5306 return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx, field.Selections, res)
5307}
5308
5309func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
5310 defer func() {
5311 if r := recover(); r != nil {
5312 ec.Error(ctx, ec.Recover(ctx, r))
5313 ret = graphql.Null
5314 }
5315 }()
5316 fc := &graphql.FieldContext{
5317 Object: "CommentConnection",
5318 Field: field,
5319 Args: nil,
5320 IsMethod: false,
5321 IsResolver: false,
5322 }
5323
5324 ctx = graphql.WithFieldContext(ctx, fc)
5325 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5326 ctx = rctx // use context from middleware stack in children
5327 return obj.PageInfo, nil
5328 })
5329 if err != nil {
5330 ec.Error(ctx, err)
5331 return graphql.Null
5332 }
5333 if resTmp == nil {
5334 if !graphql.HasFieldError(ctx, fc) {
5335 ec.Errorf(ctx, "must not be null")
5336 }
5337 return graphql.Null
5338 }
5339 res := resTmp.(*models.PageInfo)
5340 fc.Result = res
5341 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
5342}
5343
5344func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
5345 defer func() {
5346 if r := recover(); r != nil {
5347 ec.Error(ctx, ec.Recover(ctx, r))
5348 ret = graphql.Null
5349 }
5350 }()
5351 fc := &graphql.FieldContext{
5352 Object: "CommentConnection",
5353 Field: field,
5354 Args: nil,
5355 IsMethod: false,
5356 IsResolver: false,
5357 }
5358
5359 ctx = graphql.WithFieldContext(ctx, fc)
5360 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5361 ctx = rctx // use context from middleware stack in children
5362 return obj.TotalCount, nil
5363 })
5364 if err != nil {
5365 ec.Error(ctx, err)
5366 return graphql.Null
5367 }
5368 if resTmp == nil {
5369 if !graphql.HasFieldError(ctx, fc) {
5370 ec.Errorf(ctx, "must not be null")
5371 }
5372 return graphql.Null
5373 }
5374 res := resTmp.(int)
5375 fc.Result = res
5376 return ec.marshalNInt2int(ctx, field.Selections, res)
5377}
5378
5379func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
5380 defer func() {
5381 if r := recover(); r != nil {
5382 ec.Error(ctx, ec.Recover(ctx, r))
5383 ret = graphql.Null
5384 }
5385 }()
5386 fc := &graphql.FieldContext{
5387 Object: "CommentEdge",
5388 Field: field,
5389 Args: nil,
5390 IsMethod: false,
5391 IsResolver: false,
5392 }
5393
5394 ctx = graphql.WithFieldContext(ctx, fc)
5395 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5396 ctx = rctx // use context from middleware stack in children
5397 return obj.Cursor, nil
5398 })
5399 if err != nil {
5400 ec.Error(ctx, err)
5401 return graphql.Null
5402 }
5403 if resTmp == nil {
5404 if !graphql.HasFieldError(ctx, fc) {
5405 ec.Errorf(ctx, "must not be null")
5406 }
5407 return graphql.Null
5408 }
5409 res := resTmp.(string)
5410 fc.Result = res
5411 return ec.marshalNString2string(ctx, field.Selections, res)
5412}
5413
5414func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
5415 defer func() {
5416 if r := recover(); r != nil {
5417 ec.Error(ctx, ec.Recover(ctx, r))
5418 ret = graphql.Null
5419 }
5420 }()
5421 fc := &graphql.FieldContext{
5422 Object: "CommentEdge",
5423 Field: field,
5424 Args: nil,
5425 IsMethod: false,
5426 IsResolver: false,
5427 }
5428
5429 ctx = graphql.WithFieldContext(ctx, fc)
5430 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5431 ctx = rctx // use context from middleware stack in children
5432 return obj.Node, nil
5433 })
5434 if err != nil {
5435 ec.Error(ctx, err)
5436 return graphql.Null
5437 }
5438 if resTmp == nil {
5439 if !graphql.HasFieldError(ctx, fc) {
5440 ec.Errorf(ctx, "must not be null")
5441 }
5442 return graphql.Null
5443 }
5444 res := resTmp.(*bug.Comment)
5445 fc.Result = res
5446 return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
5447}
5448
5449func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
5450 defer func() {
5451 if r := recover(); r != nil {
5452 ec.Error(ctx, ec.Recover(ctx, r))
5453 ret = graphql.Null
5454 }
5455 }()
5456 fc := &graphql.FieldContext{
5457 Object: "CommentHistoryStep",
5458 Field: field,
5459 Args: nil,
5460 IsMethod: false,
5461 IsResolver: false,
5462 }
5463
5464 ctx = graphql.WithFieldContext(ctx, fc)
5465 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5466 ctx = rctx // use context from middleware stack in children
5467 return obj.Message, nil
5468 })
5469 if err != nil {
5470 ec.Error(ctx, err)
5471 return graphql.Null
5472 }
5473 if resTmp == nil {
5474 if !graphql.HasFieldError(ctx, fc) {
5475 ec.Errorf(ctx, "must not be null")
5476 }
5477 return graphql.Null
5478 }
5479 res := resTmp.(string)
5480 fc.Result = res
5481 return ec.marshalNString2string(ctx, field.Selections, res)
5482}
5483
5484func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
5485 defer func() {
5486 if r := recover(); r != nil {
5487 ec.Error(ctx, ec.Recover(ctx, r))
5488 ret = graphql.Null
5489 }
5490 }()
5491 fc := &graphql.FieldContext{
5492 Object: "CommentHistoryStep",
5493 Field: field,
5494 Args: nil,
5495 IsMethod: true,
5496 IsResolver: true,
5497 }
5498
5499 ctx = graphql.WithFieldContext(ctx, fc)
5500 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5501 ctx = rctx // use context from middleware stack in children
5502 return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
5503 })
5504 if err != nil {
5505 ec.Error(ctx, err)
5506 return graphql.Null
5507 }
5508 if resTmp == nil {
5509 if !graphql.HasFieldError(ctx, fc) {
5510 ec.Errorf(ctx, "must not be null")
5511 }
5512 return graphql.Null
5513 }
5514 res := resTmp.(*time.Time)
5515 fc.Result = res
5516 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5517}
5518
5519func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5520 defer func() {
5521 if r := recover(); r != nil {
5522 ec.Error(ctx, ec.Recover(ctx, r))
5523 ret = graphql.Null
5524 }
5525 }()
5526 fc := &graphql.FieldContext{
5527 Object: "CreateOperation",
5528 Field: field,
5529 Args: nil,
5530 IsMethod: true,
5531 IsResolver: true,
5532 }
5533
5534 ctx = graphql.WithFieldContext(ctx, fc)
5535 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5536 ctx = rctx // use context from middleware stack in children
5537 return ec.resolvers.CreateOperation().ID(rctx, obj)
5538 })
5539 if err != nil {
5540 ec.Error(ctx, err)
5541 return graphql.Null
5542 }
5543 if resTmp == nil {
5544 if !graphql.HasFieldError(ctx, fc) {
5545 ec.Errorf(ctx, "must not be null")
5546 }
5547 return graphql.Null
5548 }
5549 res := resTmp.(string)
5550 fc.Result = res
5551 return ec.marshalNString2string(ctx, field.Selections, res)
5552}
5553
5554func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5555 defer func() {
5556 if r := recover(); r != nil {
5557 ec.Error(ctx, ec.Recover(ctx, r))
5558 ret = graphql.Null
5559 }
5560 }()
5561 fc := &graphql.FieldContext{
5562 Object: "CreateOperation",
5563 Field: field,
5564 Args: nil,
5565 IsMethod: true,
5566 IsResolver: true,
5567 }
5568
5569 ctx = graphql.WithFieldContext(ctx, fc)
5570 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5571 ctx = rctx // use context from middleware stack in children
5572 return ec.resolvers.CreateOperation().Author(rctx, obj)
5573 })
5574 if err != nil {
5575 ec.Error(ctx, err)
5576 return graphql.Null
5577 }
5578 if resTmp == nil {
5579 if !graphql.HasFieldError(ctx, fc) {
5580 ec.Errorf(ctx, "must not be null")
5581 }
5582 return graphql.Null
5583 }
5584 res := resTmp.(models.IdentityWrapper)
5585 fc.Result = res
5586 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5587}
5588
5589func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5590 defer func() {
5591 if r := recover(); r != nil {
5592 ec.Error(ctx, ec.Recover(ctx, r))
5593 ret = graphql.Null
5594 }
5595 }()
5596 fc := &graphql.FieldContext{
5597 Object: "CreateOperation",
5598 Field: field,
5599 Args: nil,
5600 IsMethod: true,
5601 IsResolver: true,
5602 }
5603
5604 ctx = graphql.WithFieldContext(ctx, fc)
5605 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5606 ctx = rctx // use context from middleware stack in children
5607 return ec.resolvers.CreateOperation().Date(rctx, obj)
5608 })
5609 if err != nil {
5610 ec.Error(ctx, err)
5611 return graphql.Null
5612 }
5613 if resTmp == nil {
5614 if !graphql.HasFieldError(ctx, fc) {
5615 ec.Errorf(ctx, "must not be null")
5616 }
5617 return graphql.Null
5618 }
5619 res := resTmp.(*time.Time)
5620 fc.Result = res
5621 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5622}
5623
5624func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5625 defer func() {
5626 if r := recover(); r != nil {
5627 ec.Error(ctx, ec.Recover(ctx, r))
5628 ret = graphql.Null
5629 }
5630 }()
5631 fc := &graphql.FieldContext{
5632 Object: "CreateOperation",
5633 Field: field,
5634 Args: nil,
5635 IsMethod: false,
5636 IsResolver: false,
5637 }
5638
5639 ctx = graphql.WithFieldContext(ctx, fc)
5640 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5641 ctx = rctx // use context from middleware stack in children
5642 return obj.Title, nil
5643 })
5644 if err != nil {
5645 ec.Error(ctx, err)
5646 return graphql.Null
5647 }
5648 if resTmp == nil {
5649 if !graphql.HasFieldError(ctx, fc) {
5650 ec.Errorf(ctx, "must not be null")
5651 }
5652 return graphql.Null
5653 }
5654 res := resTmp.(string)
5655 fc.Result = res
5656 return ec.marshalNString2string(ctx, field.Selections, res)
5657}
5658
5659func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5660 defer func() {
5661 if r := recover(); r != nil {
5662 ec.Error(ctx, ec.Recover(ctx, r))
5663 ret = graphql.Null
5664 }
5665 }()
5666 fc := &graphql.FieldContext{
5667 Object: "CreateOperation",
5668 Field: field,
5669 Args: nil,
5670 IsMethod: false,
5671 IsResolver: false,
5672 }
5673
5674 ctx = graphql.WithFieldContext(ctx, fc)
5675 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5676 ctx = rctx // use context from middleware stack in children
5677 return obj.Message, nil
5678 })
5679 if err != nil {
5680 ec.Error(ctx, err)
5681 return graphql.Null
5682 }
5683 if resTmp == nil {
5684 if !graphql.HasFieldError(ctx, fc) {
5685 ec.Errorf(ctx, "must not be null")
5686 }
5687 return graphql.Null
5688 }
5689 res := resTmp.(string)
5690 fc.Result = res
5691 return ec.marshalNString2string(ctx, field.Selections, res)
5692}
5693
5694func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5695 defer func() {
5696 if r := recover(); r != nil {
5697 ec.Error(ctx, ec.Recover(ctx, r))
5698 ret = graphql.Null
5699 }
5700 }()
5701 fc := &graphql.FieldContext{
5702 Object: "CreateOperation",
5703 Field: field,
5704 Args: nil,
5705 IsMethod: false,
5706 IsResolver: false,
5707 }
5708
5709 ctx = graphql.WithFieldContext(ctx, fc)
5710 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5711 ctx = rctx // use context from middleware stack in children
5712 return obj.Files, nil
5713 })
5714 if err != nil {
5715 ec.Error(ctx, err)
5716 return graphql.Null
5717 }
5718 if resTmp == nil {
5719 if !graphql.HasFieldError(ctx, fc) {
5720 ec.Errorf(ctx, "must not be null")
5721 }
5722 return graphql.Null
5723 }
5724 res := resTmp.([]repository.Hash)
5725 fc.Result = res
5726 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
5727}
5728
5729func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5730 defer func() {
5731 if r := recover(); r != nil {
5732 ec.Error(ctx, ec.Recover(ctx, r))
5733 ret = graphql.Null
5734 }
5735 }()
5736 fc := &graphql.FieldContext{
5737 Object: "CreateTimelineItem",
5738 Field: field,
5739 Args: nil,
5740 IsMethod: true,
5741 IsResolver: true,
5742 }
5743
5744 ctx = graphql.WithFieldContext(ctx, fc)
5745 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5746 ctx = rctx // use context from middleware stack in children
5747 return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
5748 })
5749 if err != nil {
5750 ec.Error(ctx, err)
5751 return graphql.Null
5752 }
5753 if resTmp == nil {
5754 if !graphql.HasFieldError(ctx, fc) {
5755 ec.Errorf(ctx, "must not be null")
5756 }
5757 return graphql.Null
5758 }
5759 res := resTmp.(string)
5760 fc.Result = res
5761 return ec.marshalNString2string(ctx, field.Selections, res)
5762}
5763
5764func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5765 defer func() {
5766 if r := recover(); r != nil {
5767 ec.Error(ctx, ec.Recover(ctx, r))
5768 ret = graphql.Null
5769 }
5770 }()
5771 fc := &graphql.FieldContext{
5772 Object: "CreateTimelineItem",
5773 Field: field,
5774 Args: nil,
5775 IsMethod: true,
5776 IsResolver: true,
5777 }
5778
5779 ctx = graphql.WithFieldContext(ctx, fc)
5780 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5781 ctx = rctx // use context from middleware stack in children
5782 return ec.resolvers.CreateTimelineItem().Author(rctx, obj)
5783 })
5784 if err != nil {
5785 ec.Error(ctx, err)
5786 return graphql.Null
5787 }
5788 if resTmp == nil {
5789 if !graphql.HasFieldError(ctx, fc) {
5790 ec.Errorf(ctx, "must not be null")
5791 }
5792 return graphql.Null
5793 }
5794 res := resTmp.(models.IdentityWrapper)
5795 fc.Result = res
5796 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5797}
5798
5799func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5800 defer func() {
5801 if r := recover(); r != nil {
5802 ec.Error(ctx, ec.Recover(ctx, r))
5803 ret = graphql.Null
5804 }
5805 }()
5806 fc := &graphql.FieldContext{
5807 Object: "CreateTimelineItem",
5808 Field: field,
5809 Args: nil,
5810 IsMethod: false,
5811 IsResolver: false,
5812 }
5813
5814 ctx = graphql.WithFieldContext(ctx, fc)
5815 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5816 ctx = rctx // use context from middleware stack in children
5817 return obj.Message, nil
5818 })
5819 if err != nil {
5820 ec.Error(ctx, err)
5821 return graphql.Null
5822 }
5823 if resTmp == nil {
5824 if !graphql.HasFieldError(ctx, fc) {
5825 ec.Errorf(ctx, "must not be null")
5826 }
5827 return graphql.Null
5828 }
5829 res := resTmp.(string)
5830 fc.Result = res
5831 return ec.marshalNString2string(ctx, field.Selections, res)
5832}
5833
5834func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5835 defer func() {
5836 if r := recover(); r != nil {
5837 ec.Error(ctx, ec.Recover(ctx, r))
5838 ret = graphql.Null
5839 }
5840 }()
5841 fc := &graphql.FieldContext{
5842 Object: "CreateTimelineItem",
5843 Field: field,
5844 Args: nil,
5845 IsMethod: true,
5846 IsResolver: false,
5847 }
5848
5849 ctx = graphql.WithFieldContext(ctx, fc)
5850 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5851 ctx = rctx // use context from middleware stack in children
5852 return obj.MessageIsEmpty(), nil
5853 })
5854 if err != nil {
5855 ec.Error(ctx, err)
5856 return graphql.Null
5857 }
5858 if resTmp == nil {
5859 if !graphql.HasFieldError(ctx, fc) {
5860 ec.Errorf(ctx, "must not be null")
5861 }
5862 return graphql.Null
5863 }
5864 res := resTmp.(bool)
5865 fc.Result = res
5866 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5867}
5868
5869func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5870 defer func() {
5871 if r := recover(); r != nil {
5872 ec.Error(ctx, ec.Recover(ctx, r))
5873 ret = graphql.Null
5874 }
5875 }()
5876 fc := &graphql.FieldContext{
5877 Object: "CreateTimelineItem",
5878 Field: field,
5879 Args: nil,
5880 IsMethod: false,
5881 IsResolver: false,
5882 }
5883
5884 ctx = graphql.WithFieldContext(ctx, fc)
5885 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5886 ctx = rctx // use context from middleware stack in children
5887 return obj.Files, nil
5888 })
5889 if err != nil {
5890 ec.Error(ctx, err)
5891 return graphql.Null
5892 }
5893 if resTmp == nil {
5894 if !graphql.HasFieldError(ctx, fc) {
5895 ec.Errorf(ctx, "must not be null")
5896 }
5897 return graphql.Null
5898 }
5899 res := resTmp.([]repository.Hash)
5900 fc.Result = res
5901 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
5902}
5903
5904func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5905 defer func() {
5906 if r := recover(); r != nil {
5907 ec.Error(ctx, ec.Recover(ctx, r))
5908 ret = graphql.Null
5909 }
5910 }()
5911 fc := &graphql.FieldContext{
5912 Object: "CreateTimelineItem",
5913 Field: field,
5914 Args: nil,
5915 IsMethod: true,
5916 IsResolver: true,
5917 }
5918
5919 ctx = graphql.WithFieldContext(ctx, fc)
5920 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5921 ctx = rctx // use context from middleware stack in children
5922 return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
5923 })
5924 if err != nil {
5925 ec.Error(ctx, err)
5926 return graphql.Null
5927 }
5928 if resTmp == nil {
5929 if !graphql.HasFieldError(ctx, fc) {
5930 ec.Errorf(ctx, "must not be null")
5931 }
5932 return graphql.Null
5933 }
5934 res := resTmp.(*time.Time)
5935 fc.Result = res
5936 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5937}
5938
5939func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5940 defer func() {
5941 if r := recover(); r != nil {
5942 ec.Error(ctx, ec.Recover(ctx, r))
5943 ret = graphql.Null
5944 }
5945 }()
5946 fc := &graphql.FieldContext{
5947 Object: "CreateTimelineItem",
5948 Field: field,
5949 Args: nil,
5950 IsMethod: true,
5951 IsResolver: true,
5952 }
5953
5954 ctx = graphql.WithFieldContext(ctx, fc)
5955 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5956 ctx = rctx // use context from middleware stack in children
5957 return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
5958 })
5959 if err != nil {
5960 ec.Error(ctx, err)
5961 return graphql.Null
5962 }
5963 if resTmp == nil {
5964 if !graphql.HasFieldError(ctx, fc) {
5965 ec.Errorf(ctx, "must not be null")
5966 }
5967 return graphql.Null
5968 }
5969 res := resTmp.(*time.Time)
5970 fc.Result = res
5971 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5972}
5973
5974func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5975 defer func() {
5976 if r := recover(); r != nil {
5977 ec.Error(ctx, ec.Recover(ctx, r))
5978 ret = graphql.Null
5979 }
5980 }()
5981 fc := &graphql.FieldContext{
5982 Object: "CreateTimelineItem",
5983 Field: field,
5984 Args: nil,
5985 IsMethod: true,
5986 IsResolver: false,
5987 }
5988
5989 ctx = graphql.WithFieldContext(ctx, fc)
5990 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5991 ctx = rctx // use context from middleware stack in children
5992 return obj.Edited(), nil
5993 })
5994 if err != nil {
5995 ec.Error(ctx, err)
5996 return graphql.Null
5997 }
5998 if resTmp == nil {
5999 if !graphql.HasFieldError(ctx, fc) {
6000 ec.Errorf(ctx, "must not be null")
6001 }
6002 return graphql.Null
6003 }
6004 res := resTmp.(bool)
6005 fc.Result = res
6006 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
6007}
6008
6009func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
6010 defer func() {
6011 if r := recover(); r != nil {
6012 ec.Error(ctx, ec.Recover(ctx, r))
6013 ret = graphql.Null
6014 }
6015 }()
6016 fc := &graphql.FieldContext{
6017 Object: "CreateTimelineItem",
6018 Field: field,
6019 Args: nil,
6020 IsMethod: false,
6021 IsResolver: false,
6022 }
6023
6024 ctx = graphql.WithFieldContext(ctx, fc)
6025 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6026 ctx = rctx // use context from middleware stack in children
6027 return obj.History, nil
6028 })
6029 if err != nil {
6030 ec.Error(ctx, err)
6031 return graphql.Null
6032 }
6033 if resTmp == nil {
6034 if !graphql.HasFieldError(ctx, fc) {
6035 ec.Errorf(ctx, "must not be null")
6036 }
6037 return graphql.Null
6038 }
6039 res := resTmp.([]bug.CommentHistoryStep)
6040 fc.Result = res
6041 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
6042}
6043
6044func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
6045 defer func() {
6046 if r := recover(); r != nil {
6047 ec.Error(ctx, ec.Recover(ctx, r))
6048 ret = graphql.Null
6049 }
6050 }()
6051 fc := &graphql.FieldContext{
6052 Object: "EditCommentOperation",
6053 Field: field,
6054 Args: nil,
6055 IsMethod: true,
6056 IsResolver: true,
6057 }
6058
6059 ctx = graphql.WithFieldContext(ctx, fc)
6060 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6061 ctx = rctx // use context from middleware stack in children
6062 return ec.resolvers.EditCommentOperation().ID(rctx, obj)
6063 })
6064 if err != nil {
6065 ec.Error(ctx, err)
6066 return graphql.Null
6067 }
6068 if resTmp == nil {
6069 if !graphql.HasFieldError(ctx, fc) {
6070 ec.Errorf(ctx, "must not be null")
6071 }
6072 return graphql.Null
6073 }
6074 res := resTmp.(string)
6075 fc.Result = res
6076 return ec.marshalNString2string(ctx, field.Selections, res)
6077}
6078
6079func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
6080 defer func() {
6081 if r := recover(); r != nil {
6082 ec.Error(ctx, ec.Recover(ctx, r))
6083 ret = graphql.Null
6084 }
6085 }()
6086 fc := &graphql.FieldContext{
6087 Object: "EditCommentOperation",
6088 Field: field,
6089 Args: nil,
6090 IsMethod: true,
6091 IsResolver: true,
6092 }
6093
6094 ctx = graphql.WithFieldContext(ctx, fc)
6095 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6096 ctx = rctx // use context from middleware stack in children
6097 return ec.resolvers.EditCommentOperation().Author(rctx, obj)
6098 })
6099 if err != nil {
6100 ec.Error(ctx, err)
6101 return graphql.Null
6102 }
6103 if resTmp == nil {
6104 if !graphql.HasFieldError(ctx, fc) {
6105 ec.Errorf(ctx, "must not be null")
6106 }
6107 return graphql.Null
6108 }
6109 res := resTmp.(models.IdentityWrapper)
6110 fc.Result = res
6111 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6112}
6113
6114func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
6115 defer func() {
6116 if r := recover(); r != nil {
6117 ec.Error(ctx, ec.Recover(ctx, r))
6118 ret = graphql.Null
6119 }
6120 }()
6121 fc := &graphql.FieldContext{
6122 Object: "EditCommentOperation",
6123 Field: field,
6124 Args: nil,
6125 IsMethod: true,
6126 IsResolver: true,
6127 }
6128
6129 ctx = graphql.WithFieldContext(ctx, fc)
6130 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6131 ctx = rctx // use context from middleware stack in children
6132 return ec.resolvers.EditCommentOperation().Date(rctx, obj)
6133 })
6134 if err != nil {
6135 ec.Error(ctx, err)
6136 return graphql.Null
6137 }
6138 if resTmp == nil {
6139 if !graphql.HasFieldError(ctx, fc) {
6140 ec.Errorf(ctx, "must not be null")
6141 }
6142 return graphql.Null
6143 }
6144 res := resTmp.(*time.Time)
6145 fc.Result = res
6146 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6147}
6148
6149func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
6150 defer func() {
6151 if r := recover(); r != nil {
6152 ec.Error(ctx, ec.Recover(ctx, r))
6153 ret = graphql.Null
6154 }
6155 }()
6156 fc := &graphql.FieldContext{
6157 Object: "EditCommentOperation",
6158 Field: field,
6159 Args: nil,
6160 IsMethod: true,
6161 IsResolver: true,
6162 }
6163
6164 ctx = graphql.WithFieldContext(ctx, fc)
6165 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6166 ctx = rctx // use context from middleware stack in children
6167 return ec.resolvers.EditCommentOperation().Target(rctx, obj)
6168 })
6169 if err != nil {
6170 ec.Error(ctx, err)
6171 return graphql.Null
6172 }
6173 if resTmp == nil {
6174 if !graphql.HasFieldError(ctx, fc) {
6175 ec.Errorf(ctx, "must not be null")
6176 }
6177 return graphql.Null
6178 }
6179 res := resTmp.(string)
6180 fc.Result = res
6181 return ec.marshalNString2string(ctx, field.Selections, res)
6182}
6183
6184func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
6185 defer func() {
6186 if r := recover(); r != nil {
6187 ec.Error(ctx, ec.Recover(ctx, r))
6188 ret = graphql.Null
6189 }
6190 }()
6191 fc := &graphql.FieldContext{
6192 Object: "EditCommentOperation",
6193 Field: field,
6194 Args: nil,
6195 IsMethod: false,
6196 IsResolver: false,
6197 }
6198
6199 ctx = graphql.WithFieldContext(ctx, fc)
6200 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6201 ctx = rctx // use context from middleware stack in children
6202 return obj.Message, nil
6203 })
6204 if err != nil {
6205 ec.Error(ctx, err)
6206 return graphql.Null
6207 }
6208 if resTmp == nil {
6209 if !graphql.HasFieldError(ctx, fc) {
6210 ec.Errorf(ctx, "must not be null")
6211 }
6212 return graphql.Null
6213 }
6214 res := resTmp.(string)
6215 fc.Result = res
6216 return ec.marshalNString2string(ctx, field.Selections, res)
6217}
6218
6219func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
6220 defer func() {
6221 if r := recover(); r != nil {
6222 ec.Error(ctx, ec.Recover(ctx, r))
6223 ret = graphql.Null
6224 }
6225 }()
6226 fc := &graphql.FieldContext{
6227 Object: "EditCommentOperation",
6228 Field: field,
6229 Args: nil,
6230 IsMethod: false,
6231 IsResolver: false,
6232 }
6233
6234 ctx = graphql.WithFieldContext(ctx, fc)
6235 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6236 ctx = rctx // use context from middleware stack in children
6237 return obj.Files, nil
6238 })
6239 if err != nil {
6240 ec.Error(ctx, err)
6241 return graphql.Null
6242 }
6243 if resTmp == nil {
6244 if !graphql.HasFieldError(ctx, fc) {
6245 ec.Errorf(ctx, "must not be null")
6246 }
6247 return graphql.Null
6248 }
6249 res := resTmp.([]repository.Hash)
6250 fc.Result = res
6251 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
6252}
6253
6254func (ec *executionContext) _EditCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
6255 defer func() {
6256 if r := recover(); r != nil {
6257 ec.Error(ctx, ec.Recover(ctx, r))
6258 ret = graphql.Null
6259 }
6260 }()
6261 fc := &graphql.FieldContext{
6262 Object: "EditCommentPayload",
6263 Field: field,
6264 Args: nil,
6265 IsMethod: false,
6266 IsResolver: false,
6267 }
6268
6269 ctx = graphql.WithFieldContext(ctx, fc)
6270 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6271 ctx = rctx // use context from middleware stack in children
6272 return obj.ClientMutationID, nil
6273 })
6274 if err != nil {
6275 ec.Error(ctx, err)
6276 return graphql.Null
6277 }
6278 if resTmp == nil {
6279 return graphql.Null
6280 }
6281 res := resTmp.(*string)
6282 fc.Result = res
6283 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
6284}
6285
6286func (ec *executionContext) _EditCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
6287 defer func() {
6288 if r := recover(); r != nil {
6289 ec.Error(ctx, ec.Recover(ctx, r))
6290 ret = graphql.Null
6291 }
6292 }()
6293 fc := &graphql.FieldContext{
6294 Object: "EditCommentPayload",
6295 Field: field,
6296 Args: nil,
6297 IsMethod: false,
6298 IsResolver: false,
6299 }
6300
6301 ctx = graphql.WithFieldContext(ctx, fc)
6302 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6303 ctx = rctx // use context from middleware stack in children
6304 return obj.Bug, nil
6305 })
6306 if err != nil {
6307 ec.Error(ctx, err)
6308 return graphql.Null
6309 }
6310 if resTmp == nil {
6311 if !graphql.HasFieldError(ctx, fc) {
6312 ec.Errorf(ctx, "must not be null")
6313 }
6314 return graphql.Null
6315 }
6316 res := resTmp.(models.BugWrapper)
6317 fc.Result = res
6318 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
6319}
6320
6321func (ec *executionContext) _EditCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
6322 defer func() {
6323 if r := recover(); r != nil {
6324 ec.Error(ctx, ec.Recover(ctx, r))
6325 ret = graphql.Null
6326 }
6327 }()
6328 fc := &graphql.FieldContext{
6329 Object: "EditCommentPayload",
6330 Field: field,
6331 Args: nil,
6332 IsMethod: false,
6333 IsResolver: false,
6334 }
6335
6336 ctx = graphql.WithFieldContext(ctx, fc)
6337 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6338 ctx = rctx // use context from middleware stack in children
6339 return obj.Operation, nil
6340 })
6341 if err != nil {
6342 ec.Error(ctx, err)
6343 return graphql.Null
6344 }
6345 if resTmp == nil {
6346 if !graphql.HasFieldError(ctx, fc) {
6347 ec.Errorf(ctx, "must not be null")
6348 }
6349 return graphql.Null
6350 }
6351 res := resTmp.(*bug.EditCommentOperation)
6352 fc.Result = res
6353 return ec.marshalNEditCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐEditCommentOperation(ctx, field.Selections, res)
6354}
6355
6356func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6357 defer func() {
6358 if r := recover(); r != nil {
6359 ec.Error(ctx, ec.Recover(ctx, r))
6360 ret = graphql.Null
6361 }
6362 }()
6363 fc := &graphql.FieldContext{
6364 Object: "Identity",
6365 Field: field,
6366 Args: nil,
6367 IsMethod: true,
6368 IsResolver: true,
6369 }
6370
6371 ctx = graphql.WithFieldContext(ctx, fc)
6372 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6373 ctx = rctx // use context from middleware stack in children
6374 return ec.resolvers.Identity().ID(rctx, obj)
6375 })
6376 if err != nil {
6377 ec.Error(ctx, err)
6378 return graphql.Null
6379 }
6380 if resTmp == nil {
6381 if !graphql.HasFieldError(ctx, fc) {
6382 ec.Errorf(ctx, "must not be null")
6383 }
6384 return graphql.Null
6385 }
6386 res := resTmp.(string)
6387 fc.Result = res
6388 return ec.marshalNString2string(ctx, field.Selections, res)
6389}
6390
6391func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6392 defer func() {
6393 if r := recover(); r != nil {
6394 ec.Error(ctx, ec.Recover(ctx, r))
6395 ret = graphql.Null
6396 }
6397 }()
6398 fc := &graphql.FieldContext{
6399 Object: "Identity",
6400 Field: field,
6401 Args: nil,
6402 IsMethod: true,
6403 IsResolver: true,
6404 }
6405
6406 ctx = graphql.WithFieldContext(ctx, fc)
6407 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6408 ctx = rctx // use context from middleware stack in children
6409 return ec.resolvers.Identity().HumanID(rctx, obj)
6410 })
6411 if err != nil {
6412 ec.Error(ctx, err)
6413 return graphql.Null
6414 }
6415 if resTmp == nil {
6416 if !graphql.HasFieldError(ctx, fc) {
6417 ec.Errorf(ctx, "must not be null")
6418 }
6419 return graphql.Null
6420 }
6421 res := resTmp.(string)
6422 fc.Result = res
6423 return ec.marshalNString2string(ctx, field.Selections, res)
6424}
6425
6426func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6427 defer func() {
6428 if r := recover(); r != nil {
6429 ec.Error(ctx, ec.Recover(ctx, r))
6430 ret = graphql.Null
6431 }
6432 }()
6433 fc := &graphql.FieldContext{
6434 Object: "Identity",
6435 Field: field,
6436 Args: nil,
6437 IsMethod: true,
6438 IsResolver: false,
6439 }
6440
6441 ctx = graphql.WithFieldContext(ctx, fc)
6442 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6443 ctx = rctx // use context from middleware stack in children
6444 return obj.Name(), nil
6445 })
6446 if err != nil {
6447 ec.Error(ctx, err)
6448 return graphql.Null
6449 }
6450 if resTmp == nil {
6451 return graphql.Null
6452 }
6453 res := resTmp.(string)
6454 fc.Result = res
6455 return ec.marshalOString2string(ctx, field.Selections, res)
6456}
6457
6458func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6459 defer func() {
6460 if r := recover(); r != nil {
6461 ec.Error(ctx, ec.Recover(ctx, r))
6462 ret = graphql.Null
6463 }
6464 }()
6465 fc := &graphql.FieldContext{
6466 Object: "Identity",
6467 Field: field,
6468 Args: nil,
6469 IsMethod: true,
6470 IsResolver: false,
6471 }
6472
6473 ctx = graphql.WithFieldContext(ctx, fc)
6474 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6475 ctx = rctx // use context from middleware stack in children
6476 return obj.Email()
6477 })
6478 if err != nil {
6479 ec.Error(ctx, err)
6480 return graphql.Null
6481 }
6482 if resTmp == nil {
6483 return graphql.Null
6484 }
6485 res := resTmp.(string)
6486 fc.Result = res
6487 return ec.marshalOString2string(ctx, field.Selections, res)
6488}
6489
6490func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6491 defer func() {
6492 if r := recover(); r != nil {
6493 ec.Error(ctx, ec.Recover(ctx, r))
6494 ret = graphql.Null
6495 }
6496 }()
6497 fc := &graphql.FieldContext{
6498 Object: "Identity",
6499 Field: field,
6500 Args: nil,
6501 IsMethod: true,
6502 IsResolver: false,
6503 }
6504
6505 ctx = graphql.WithFieldContext(ctx, fc)
6506 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6507 ctx = rctx // use context from middleware stack in children
6508 return obj.Login()
6509 })
6510 if err != nil {
6511 ec.Error(ctx, err)
6512 return graphql.Null
6513 }
6514 if resTmp == nil {
6515 return graphql.Null
6516 }
6517 res := resTmp.(string)
6518 fc.Result = res
6519 return ec.marshalOString2string(ctx, field.Selections, res)
6520}
6521
6522func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6523 defer func() {
6524 if r := recover(); r != nil {
6525 ec.Error(ctx, ec.Recover(ctx, r))
6526 ret = graphql.Null
6527 }
6528 }()
6529 fc := &graphql.FieldContext{
6530 Object: "Identity",
6531 Field: field,
6532 Args: nil,
6533 IsMethod: true,
6534 IsResolver: false,
6535 }
6536
6537 ctx = graphql.WithFieldContext(ctx, fc)
6538 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6539 ctx = rctx // use context from middleware stack in children
6540 return obj.DisplayName(), nil
6541 })
6542 if err != nil {
6543 ec.Error(ctx, err)
6544 return graphql.Null
6545 }
6546 if resTmp == nil {
6547 if !graphql.HasFieldError(ctx, fc) {
6548 ec.Errorf(ctx, "must not be null")
6549 }
6550 return graphql.Null
6551 }
6552 res := resTmp.(string)
6553 fc.Result = res
6554 return ec.marshalNString2string(ctx, field.Selections, res)
6555}
6556
6557func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6558 defer func() {
6559 if r := recover(); r != nil {
6560 ec.Error(ctx, ec.Recover(ctx, r))
6561 ret = graphql.Null
6562 }
6563 }()
6564 fc := &graphql.FieldContext{
6565 Object: "Identity",
6566 Field: field,
6567 Args: nil,
6568 IsMethod: true,
6569 IsResolver: false,
6570 }
6571
6572 ctx = graphql.WithFieldContext(ctx, fc)
6573 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6574 ctx = rctx // use context from middleware stack in children
6575 return obj.AvatarUrl()
6576 })
6577 if err != nil {
6578 ec.Error(ctx, err)
6579 return graphql.Null
6580 }
6581 if resTmp == nil {
6582 return graphql.Null
6583 }
6584 res := resTmp.(string)
6585 fc.Result = res
6586 return ec.marshalOString2string(ctx, field.Selections, res)
6587}
6588
6589func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6590 defer func() {
6591 if r := recover(); r != nil {
6592 ec.Error(ctx, ec.Recover(ctx, r))
6593 ret = graphql.Null
6594 }
6595 }()
6596 fc := &graphql.FieldContext{
6597 Object: "Identity",
6598 Field: field,
6599 Args: nil,
6600 IsMethod: true,
6601 IsResolver: false,
6602 }
6603
6604 ctx = graphql.WithFieldContext(ctx, fc)
6605 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6606 ctx = rctx // use context from middleware stack in children
6607 return obj.IsProtected()
6608 })
6609 if err != nil {
6610 ec.Error(ctx, err)
6611 return graphql.Null
6612 }
6613 if resTmp == nil {
6614 if !graphql.HasFieldError(ctx, fc) {
6615 ec.Errorf(ctx, "must not be null")
6616 }
6617 return graphql.Null
6618 }
6619 res := resTmp.(bool)
6620 fc.Result = res
6621 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
6622}
6623
6624func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6625 defer func() {
6626 if r := recover(); r != nil {
6627 ec.Error(ctx, ec.Recover(ctx, r))
6628 ret = graphql.Null
6629 }
6630 }()
6631 fc := &graphql.FieldContext{
6632 Object: "IdentityConnection",
6633 Field: field,
6634 Args: nil,
6635 IsMethod: false,
6636 IsResolver: false,
6637 }
6638
6639 ctx = graphql.WithFieldContext(ctx, fc)
6640 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6641 ctx = rctx // use context from middleware stack in children
6642 return obj.Edges, nil
6643 })
6644 if err != nil {
6645 ec.Error(ctx, err)
6646 return graphql.Null
6647 }
6648 if resTmp == nil {
6649 if !graphql.HasFieldError(ctx, fc) {
6650 ec.Errorf(ctx, "must not be null")
6651 }
6652 return graphql.Null
6653 }
6654 res := resTmp.([]*models.IdentityEdge)
6655 fc.Result = res
6656 return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx, field.Selections, res)
6657}
6658
6659func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6660 defer func() {
6661 if r := recover(); r != nil {
6662 ec.Error(ctx, ec.Recover(ctx, r))
6663 ret = graphql.Null
6664 }
6665 }()
6666 fc := &graphql.FieldContext{
6667 Object: "IdentityConnection",
6668 Field: field,
6669 Args: nil,
6670 IsMethod: false,
6671 IsResolver: false,
6672 }
6673
6674 ctx = graphql.WithFieldContext(ctx, fc)
6675 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6676 ctx = rctx // use context from middleware stack in children
6677 return obj.Nodes, nil
6678 })
6679 if err != nil {
6680 ec.Error(ctx, err)
6681 return graphql.Null
6682 }
6683 if resTmp == nil {
6684 if !graphql.HasFieldError(ctx, fc) {
6685 ec.Errorf(ctx, "must not be null")
6686 }
6687 return graphql.Null
6688 }
6689 res := resTmp.([]models.IdentityWrapper)
6690 fc.Result = res
6691 return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx, field.Selections, res)
6692}
6693
6694func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6695 defer func() {
6696 if r := recover(); r != nil {
6697 ec.Error(ctx, ec.Recover(ctx, r))
6698 ret = graphql.Null
6699 }
6700 }()
6701 fc := &graphql.FieldContext{
6702 Object: "IdentityConnection",
6703 Field: field,
6704 Args: nil,
6705 IsMethod: false,
6706 IsResolver: false,
6707 }
6708
6709 ctx = graphql.WithFieldContext(ctx, fc)
6710 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6711 ctx = rctx // use context from middleware stack in children
6712 return obj.PageInfo, nil
6713 })
6714 if err != nil {
6715 ec.Error(ctx, err)
6716 return graphql.Null
6717 }
6718 if resTmp == nil {
6719 if !graphql.HasFieldError(ctx, fc) {
6720 ec.Errorf(ctx, "must not be null")
6721 }
6722 return graphql.Null
6723 }
6724 res := resTmp.(*models.PageInfo)
6725 fc.Result = res
6726 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
6727}
6728
6729func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6730 defer func() {
6731 if r := recover(); r != nil {
6732 ec.Error(ctx, ec.Recover(ctx, r))
6733 ret = graphql.Null
6734 }
6735 }()
6736 fc := &graphql.FieldContext{
6737 Object: "IdentityConnection",
6738 Field: field,
6739 Args: nil,
6740 IsMethod: false,
6741 IsResolver: false,
6742 }
6743
6744 ctx = graphql.WithFieldContext(ctx, fc)
6745 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6746 ctx = rctx // use context from middleware stack in children
6747 return obj.TotalCount, nil
6748 })
6749 if err != nil {
6750 ec.Error(ctx, err)
6751 return graphql.Null
6752 }
6753 if resTmp == nil {
6754 if !graphql.HasFieldError(ctx, fc) {
6755 ec.Errorf(ctx, "must not be null")
6756 }
6757 return graphql.Null
6758 }
6759 res := resTmp.(int)
6760 fc.Result = res
6761 return ec.marshalNInt2int(ctx, field.Selections, res)
6762}
6763
6764func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6765 defer func() {
6766 if r := recover(); r != nil {
6767 ec.Error(ctx, ec.Recover(ctx, r))
6768 ret = graphql.Null
6769 }
6770 }()
6771 fc := &graphql.FieldContext{
6772 Object: "IdentityEdge",
6773 Field: field,
6774 Args: nil,
6775 IsMethod: false,
6776 IsResolver: false,
6777 }
6778
6779 ctx = graphql.WithFieldContext(ctx, fc)
6780 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6781 ctx = rctx // use context from middleware stack in children
6782 return obj.Cursor, nil
6783 })
6784 if err != nil {
6785 ec.Error(ctx, err)
6786 return graphql.Null
6787 }
6788 if resTmp == nil {
6789 if !graphql.HasFieldError(ctx, fc) {
6790 ec.Errorf(ctx, "must not be null")
6791 }
6792 return graphql.Null
6793 }
6794 res := resTmp.(string)
6795 fc.Result = res
6796 return ec.marshalNString2string(ctx, field.Selections, res)
6797}
6798
6799func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6800 defer func() {
6801 if r := recover(); r != nil {
6802 ec.Error(ctx, ec.Recover(ctx, r))
6803 ret = graphql.Null
6804 }
6805 }()
6806 fc := &graphql.FieldContext{
6807 Object: "IdentityEdge",
6808 Field: field,
6809 Args: nil,
6810 IsMethod: false,
6811 IsResolver: false,
6812 }
6813
6814 ctx = graphql.WithFieldContext(ctx, fc)
6815 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6816 ctx = rctx // use context from middleware stack in children
6817 return obj.Node, nil
6818 })
6819 if err != nil {
6820 ec.Error(ctx, err)
6821 return graphql.Null
6822 }
6823 if resTmp == nil {
6824 if !graphql.HasFieldError(ctx, fc) {
6825 ec.Errorf(ctx, "must not be null")
6826 }
6827 return graphql.Null
6828 }
6829 res := resTmp.(models.IdentityWrapper)
6830 fc.Result = res
6831 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6832}
6833
6834func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6835 defer func() {
6836 if r := recover(); r != nil {
6837 ec.Error(ctx, ec.Recover(ctx, r))
6838 ret = graphql.Null
6839 }
6840 }()
6841 fc := &graphql.FieldContext{
6842 Object: "Label",
6843 Field: field,
6844 Args: nil,
6845 IsMethod: true,
6846 IsResolver: true,
6847 }
6848
6849 ctx = graphql.WithFieldContext(ctx, fc)
6850 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6851 ctx = rctx // use context from middleware stack in children
6852 return ec.resolvers.Label().Name(rctx, obj)
6853 })
6854 if err != nil {
6855 ec.Error(ctx, err)
6856 return graphql.Null
6857 }
6858 if resTmp == nil {
6859 if !graphql.HasFieldError(ctx, fc) {
6860 ec.Errorf(ctx, "must not be null")
6861 }
6862 return graphql.Null
6863 }
6864 res := resTmp.(string)
6865 fc.Result = res
6866 return ec.marshalNString2string(ctx, field.Selections, res)
6867}
6868
6869func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6870 defer func() {
6871 if r := recover(); r != nil {
6872 ec.Error(ctx, ec.Recover(ctx, r))
6873 ret = graphql.Null
6874 }
6875 }()
6876 fc := &graphql.FieldContext{
6877 Object: "Label",
6878 Field: field,
6879 Args: nil,
6880 IsMethod: true,
6881 IsResolver: true,
6882 }
6883
6884 ctx = graphql.WithFieldContext(ctx, fc)
6885 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6886 ctx = rctx // use context from middleware stack in children
6887 return ec.resolvers.Label().Color(rctx, obj)
6888 })
6889 if err != nil {
6890 ec.Error(ctx, err)
6891 return graphql.Null
6892 }
6893 if resTmp == nil {
6894 if !graphql.HasFieldError(ctx, fc) {
6895 ec.Errorf(ctx, "must not be null")
6896 }
6897 return graphql.Null
6898 }
6899 res := resTmp.(*color.RGBA)
6900 fc.Result = res
6901 return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
6902}
6903
6904func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6905 defer func() {
6906 if r := recover(); r != nil {
6907 ec.Error(ctx, ec.Recover(ctx, r))
6908 ret = graphql.Null
6909 }
6910 }()
6911 fc := &graphql.FieldContext{
6912 Object: "LabelChangeOperation",
6913 Field: field,
6914 Args: nil,
6915 IsMethod: true,
6916 IsResolver: true,
6917 }
6918
6919 ctx = graphql.WithFieldContext(ctx, fc)
6920 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6921 ctx = rctx // use context from middleware stack in children
6922 return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
6923 })
6924 if err != nil {
6925 ec.Error(ctx, err)
6926 return graphql.Null
6927 }
6928 if resTmp == nil {
6929 if !graphql.HasFieldError(ctx, fc) {
6930 ec.Errorf(ctx, "must not be null")
6931 }
6932 return graphql.Null
6933 }
6934 res := resTmp.(string)
6935 fc.Result = res
6936 return ec.marshalNString2string(ctx, field.Selections, res)
6937}
6938
6939func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6940 defer func() {
6941 if r := recover(); r != nil {
6942 ec.Error(ctx, ec.Recover(ctx, r))
6943 ret = graphql.Null
6944 }
6945 }()
6946 fc := &graphql.FieldContext{
6947 Object: "LabelChangeOperation",
6948 Field: field,
6949 Args: nil,
6950 IsMethod: true,
6951 IsResolver: true,
6952 }
6953
6954 ctx = graphql.WithFieldContext(ctx, fc)
6955 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6956 ctx = rctx // use context from middleware stack in children
6957 return ec.resolvers.LabelChangeOperation().Author(rctx, obj)
6958 })
6959 if err != nil {
6960 ec.Error(ctx, err)
6961 return graphql.Null
6962 }
6963 if resTmp == nil {
6964 if !graphql.HasFieldError(ctx, fc) {
6965 ec.Errorf(ctx, "must not be null")
6966 }
6967 return graphql.Null
6968 }
6969 res := resTmp.(models.IdentityWrapper)
6970 fc.Result = res
6971 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6972}
6973
6974func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6975 defer func() {
6976 if r := recover(); r != nil {
6977 ec.Error(ctx, ec.Recover(ctx, r))
6978 ret = graphql.Null
6979 }
6980 }()
6981 fc := &graphql.FieldContext{
6982 Object: "LabelChangeOperation",
6983 Field: field,
6984 Args: nil,
6985 IsMethod: true,
6986 IsResolver: true,
6987 }
6988
6989 ctx = graphql.WithFieldContext(ctx, fc)
6990 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6991 ctx = rctx // use context from middleware stack in children
6992 return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
6993 })
6994 if err != nil {
6995 ec.Error(ctx, err)
6996 return graphql.Null
6997 }
6998 if resTmp == nil {
6999 if !graphql.HasFieldError(ctx, fc) {
7000 ec.Errorf(ctx, "must not be null")
7001 }
7002 return graphql.Null
7003 }
7004 res := resTmp.(*time.Time)
7005 fc.Result = res
7006 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
7007}
7008
7009func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
7010 defer func() {
7011 if r := recover(); r != nil {
7012 ec.Error(ctx, ec.Recover(ctx, r))
7013 ret = graphql.Null
7014 }
7015 }()
7016 fc := &graphql.FieldContext{
7017 Object: "LabelChangeOperation",
7018 Field: field,
7019 Args: nil,
7020 IsMethod: false,
7021 IsResolver: false,
7022 }
7023
7024 ctx = graphql.WithFieldContext(ctx, fc)
7025 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7026 ctx = rctx // use context from middleware stack in children
7027 return obj.Added, nil
7028 })
7029 if err != nil {
7030 ec.Error(ctx, err)
7031 return graphql.Null
7032 }
7033 if resTmp == nil {
7034 if !graphql.HasFieldError(ctx, fc) {
7035 ec.Errorf(ctx, "must not be null")
7036 }
7037 return graphql.Null
7038 }
7039 res := resTmp.([]bug.Label)
7040 fc.Result = res
7041 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
7042}
7043
7044func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
7045 defer func() {
7046 if r := recover(); r != nil {
7047 ec.Error(ctx, ec.Recover(ctx, r))
7048 ret = graphql.Null
7049 }
7050 }()
7051 fc := &graphql.FieldContext{
7052 Object: "LabelChangeOperation",
7053 Field: field,
7054 Args: nil,
7055 IsMethod: false,
7056 IsResolver: false,
7057 }
7058
7059 ctx = graphql.WithFieldContext(ctx, fc)
7060 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7061 ctx = rctx // use context from middleware stack in children
7062 return obj.Removed, nil
7063 })
7064 if err != nil {
7065 ec.Error(ctx, err)
7066 return graphql.Null
7067 }
7068 if resTmp == nil {
7069 if !graphql.HasFieldError(ctx, fc) {
7070 ec.Errorf(ctx, "must not be null")
7071 }
7072 return graphql.Null
7073 }
7074 res := resTmp.([]bug.Label)
7075 fc.Result = res
7076 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
7077}
7078
7079func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
7080 defer func() {
7081 if r := recover(); r != nil {
7082 ec.Error(ctx, ec.Recover(ctx, r))
7083 ret = graphql.Null
7084 }
7085 }()
7086 fc := &graphql.FieldContext{
7087 Object: "LabelChangeResult",
7088 Field: field,
7089 Args: nil,
7090 IsMethod: false,
7091 IsResolver: false,
7092 }
7093
7094 ctx = graphql.WithFieldContext(ctx, fc)
7095 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7096 ctx = rctx // use context from middleware stack in children
7097 return obj.Label, nil
7098 })
7099 if err != nil {
7100 ec.Error(ctx, err)
7101 return graphql.Null
7102 }
7103 if resTmp == nil {
7104 if !graphql.HasFieldError(ctx, fc) {
7105 ec.Errorf(ctx, "must not be null")
7106 }
7107 return graphql.Null
7108 }
7109 res := resTmp.(bug.Label)
7110 fc.Result = res
7111 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
7112}
7113
7114func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
7115 defer func() {
7116 if r := recover(); r != nil {
7117 ec.Error(ctx, ec.Recover(ctx, r))
7118 ret = graphql.Null
7119 }
7120 }()
7121 fc := &graphql.FieldContext{
7122 Object: "LabelChangeResult",
7123 Field: field,
7124 Args: nil,
7125 IsMethod: true,
7126 IsResolver: true,
7127 }
7128
7129 ctx = graphql.WithFieldContext(ctx, fc)
7130 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7131 ctx = rctx // use context from middleware stack in children
7132 return ec.resolvers.LabelChangeResult().Status(rctx, obj)
7133 })
7134 if err != nil {
7135 ec.Error(ctx, err)
7136 return graphql.Null
7137 }
7138 if resTmp == nil {
7139 if !graphql.HasFieldError(ctx, fc) {
7140 ec.Errorf(ctx, "must not be null")
7141 }
7142 return graphql.Null
7143 }
7144 res := resTmp.(models.LabelChangeStatus)
7145 fc.Result = res
7146 return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
7147}
7148
7149func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
7150 defer func() {
7151 if r := recover(); r != nil {
7152 ec.Error(ctx, ec.Recover(ctx, r))
7153 ret = graphql.Null
7154 }
7155 }()
7156 fc := &graphql.FieldContext{
7157 Object: "LabelChangeTimelineItem",
7158 Field: field,
7159 Args: nil,
7160 IsMethod: true,
7161 IsResolver: true,
7162 }
7163
7164 ctx = graphql.WithFieldContext(ctx, fc)
7165 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7166 ctx = rctx // use context from middleware stack in children
7167 return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
7168 })
7169 if err != nil {
7170 ec.Error(ctx, err)
7171 return graphql.Null
7172 }
7173 if resTmp == nil {
7174 if !graphql.HasFieldError(ctx, fc) {
7175 ec.Errorf(ctx, "must not be null")
7176 }
7177 return graphql.Null
7178 }
7179 res := resTmp.(string)
7180 fc.Result = res
7181 return ec.marshalNString2string(ctx, field.Selections, res)
7182}
7183
7184func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
7185 defer func() {
7186 if r := recover(); r != nil {
7187 ec.Error(ctx, ec.Recover(ctx, r))
7188 ret = graphql.Null
7189 }
7190 }()
7191 fc := &graphql.FieldContext{
7192 Object: "LabelChangeTimelineItem",
7193 Field: field,
7194 Args: nil,
7195 IsMethod: true,
7196 IsResolver: true,
7197 }
7198
7199 ctx = graphql.WithFieldContext(ctx, fc)
7200 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7201 ctx = rctx // use context from middleware stack in children
7202 return ec.resolvers.LabelChangeTimelineItem().Author(rctx, obj)
7203 })
7204 if err != nil {
7205 ec.Error(ctx, err)
7206 return graphql.Null
7207 }
7208 if resTmp == nil {
7209 if !graphql.HasFieldError(ctx, fc) {
7210 ec.Errorf(ctx, "must not be null")
7211 }
7212 return graphql.Null
7213 }
7214 res := resTmp.(models.IdentityWrapper)
7215 fc.Result = res
7216 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
7217}
7218
7219func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
7220 defer func() {
7221 if r := recover(); r != nil {
7222 ec.Error(ctx, ec.Recover(ctx, r))
7223 ret = graphql.Null
7224 }
7225 }()
7226 fc := &graphql.FieldContext{
7227 Object: "LabelChangeTimelineItem",
7228 Field: field,
7229 Args: nil,
7230 IsMethod: true,
7231 IsResolver: true,
7232 }
7233
7234 ctx = graphql.WithFieldContext(ctx, fc)
7235 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7236 ctx = rctx // use context from middleware stack in children
7237 return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
7238 })
7239 if err != nil {
7240 ec.Error(ctx, err)
7241 return graphql.Null
7242 }
7243 if resTmp == nil {
7244 if !graphql.HasFieldError(ctx, fc) {
7245 ec.Errorf(ctx, "must not be null")
7246 }
7247 return graphql.Null
7248 }
7249 res := resTmp.(*time.Time)
7250 fc.Result = res
7251 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
7252}
7253
7254func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
7255 defer func() {
7256 if r := recover(); r != nil {
7257 ec.Error(ctx, ec.Recover(ctx, r))
7258 ret = graphql.Null
7259 }
7260 }()
7261 fc := &graphql.FieldContext{
7262 Object: "LabelChangeTimelineItem",
7263 Field: field,
7264 Args: nil,
7265 IsMethod: false,
7266 IsResolver: false,
7267 }
7268
7269 ctx = graphql.WithFieldContext(ctx, fc)
7270 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7271 ctx = rctx // use context from middleware stack in children
7272 return obj.Added, nil
7273 })
7274 if err != nil {
7275 ec.Error(ctx, err)
7276 return graphql.Null
7277 }
7278 if resTmp == nil {
7279 if !graphql.HasFieldError(ctx, fc) {
7280 ec.Errorf(ctx, "must not be null")
7281 }
7282 return graphql.Null
7283 }
7284 res := resTmp.([]bug.Label)
7285 fc.Result = res
7286 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
7287}
7288
7289func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
7290 defer func() {
7291 if r := recover(); r != nil {
7292 ec.Error(ctx, ec.Recover(ctx, r))
7293 ret = graphql.Null
7294 }
7295 }()
7296 fc := &graphql.FieldContext{
7297 Object: "LabelChangeTimelineItem",
7298 Field: field,
7299 Args: nil,
7300 IsMethod: false,
7301 IsResolver: false,
7302 }
7303
7304 ctx = graphql.WithFieldContext(ctx, fc)
7305 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7306 ctx = rctx // use context from middleware stack in children
7307 return obj.Removed, nil
7308 })
7309 if err != nil {
7310 ec.Error(ctx, err)
7311 return graphql.Null
7312 }
7313 if resTmp == nil {
7314 if !graphql.HasFieldError(ctx, fc) {
7315 ec.Errorf(ctx, "must not be null")
7316 }
7317 return graphql.Null
7318 }
7319 res := resTmp.([]bug.Label)
7320 fc.Result = res
7321 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
7322}
7323
7324func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7325 defer func() {
7326 if r := recover(); r != nil {
7327 ec.Error(ctx, ec.Recover(ctx, r))
7328 ret = graphql.Null
7329 }
7330 }()
7331 fc := &graphql.FieldContext{
7332 Object: "LabelConnection",
7333 Field: field,
7334 Args: nil,
7335 IsMethod: false,
7336 IsResolver: false,
7337 }
7338
7339 ctx = graphql.WithFieldContext(ctx, fc)
7340 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7341 ctx = rctx // use context from middleware stack in children
7342 return obj.Edges, nil
7343 })
7344 if err != nil {
7345 ec.Error(ctx, err)
7346 return graphql.Null
7347 }
7348 if resTmp == nil {
7349 if !graphql.HasFieldError(ctx, fc) {
7350 ec.Errorf(ctx, "must not be null")
7351 }
7352 return graphql.Null
7353 }
7354 res := resTmp.([]*models.LabelEdge)
7355 fc.Result = res
7356 return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx, field.Selections, res)
7357}
7358
7359func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7360 defer func() {
7361 if r := recover(); r != nil {
7362 ec.Error(ctx, ec.Recover(ctx, r))
7363 ret = graphql.Null
7364 }
7365 }()
7366 fc := &graphql.FieldContext{
7367 Object: "LabelConnection",
7368 Field: field,
7369 Args: nil,
7370 IsMethod: false,
7371 IsResolver: false,
7372 }
7373
7374 ctx = graphql.WithFieldContext(ctx, fc)
7375 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7376 ctx = rctx // use context from middleware stack in children
7377 return obj.Nodes, nil
7378 })
7379 if err != nil {
7380 ec.Error(ctx, err)
7381 return graphql.Null
7382 }
7383 if resTmp == nil {
7384 if !graphql.HasFieldError(ctx, fc) {
7385 ec.Errorf(ctx, "must not be null")
7386 }
7387 return graphql.Null
7388 }
7389 res := resTmp.([]bug.Label)
7390 fc.Result = res
7391 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
7392}
7393
7394func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7395 defer func() {
7396 if r := recover(); r != nil {
7397 ec.Error(ctx, ec.Recover(ctx, r))
7398 ret = graphql.Null
7399 }
7400 }()
7401 fc := &graphql.FieldContext{
7402 Object: "LabelConnection",
7403 Field: field,
7404 Args: nil,
7405 IsMethod: false,
7406 IsResolver: false,
7407 }
7408
7409 ctx = graphql.WithFieldContext(ctx, fc)
7410 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7411 ctx = rctx // use context from middleware stack in children
7412 return obj.PageInfo, nil
7413 })
7414 if err != nil {
7415 ec.Error(ctx, err)
7416 return graphql.Null
7417 }
7418 if resTmp == nil {
7419 if !graphql.HasFieldError(ctx, fc) {
7420 ec.Errorf(ctx, "must not be null")
7421 }
7422 return graphql.Null
7423 }
7424 res := resTmp.(*models.PageInfo)
7425 fc.Result = res
7426 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
7427}
7428
7429func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7430 defer func() {
7431 if r := recover(); r != nil {
7432 ec.Error(ctx, ec.Recover(ctx, r))
7433 ret = graphql.Null
7434 }
7435 }()
7436 fc := &graphql.FieldContext{
7437 Object: "LabelConnection",
7438 Field: field,
7439 Args: nil,
7440 IsMethod: false,
7441 IsResolver: false,
7442 }
7443
7444 ctx = graphql.WithFieldContext(ctx, fc)
7445 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7446 ctx = rctx // use context from middleware stack in children
7447 return obj.TotalCount, nil
7448 })
7449 if err != nil {
7450 ec.Error(ctx, err)
7451 return graphql.Null
7452 }
7453 if resTmp == nil {
7454 if !graphql.HasFieldError(ctx, fc) {
7455 ec.Errorf(ctx, "must not be null")
7456 }
7457 return graphql.Null
7458 }
7459 res := resTmp.(int)
7460 fc.Result = res
7461 return ec.marshalNInt2int(ctx, field.Selections, res)
7462}
7463
7464func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
7465 defer func() {
7466 if r := recover(); r != nil {
7467 ec.Error(ctx, ec.Recover(ctx, r))
7468 ret = graphql.Null
7469 }
7470 }()
7471 fc := &graphql.FieldContext{
7472 Object: "LabelEdge",
7473 Field: field,
7474 Args: nil,
7475 IsMethod: false,
7476 IsResolver: false,
7477 }
7478
7479 ctx = graphql.WithFieldContext(ctx, fc)
7480 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7481 ctx = rctx // use context from middleware stack in children
7482 return obj.Cursor, nil
7483 })
7484 if err != nil {
7485 ec.Error(ctx, err)
7486 return graphql.Null
7487 }
7488 if resTmp == nil {
7489 if !graphql.HasFieldError(ctx, fc) {
7490 ec.Errorf(ctx, "must not be null")
7491 }
7492 return graphql.Null
7493 }
7494 res := resTmp.(string)
7495 fc.Result = res
7496 return ec.marshalNString2string(ctx, field.Selections, res)
7497}
7498
7499func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
7500 defer func() {
7501 if r := recover(); r != nil {
7502 ec.Error(ctx, ec.Recover(ctx, r))
7503 ret = graphql.Null
7504 }
7505 }()
7506 fc := &graphql.FieldContext{
7507 Object: "LabelEdge",
7508 Field: field,
7509 Args: nil,
7510 IsMethod: false,
7511 IsResolver: false,
7512 }
7513
7514 ctx = graphql.WithFieldContext(ctx, fc)
7515 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7516 ctx = rctx // use context from middleware stack in children
7517 return obj.Node, nil
7518 })
7519 if err != nil {
7520 ec.Error(ctx, err)
7521 return graphql.Null
7522 }
7523 if resTmp == nil {
7524 if !graphql.HasFieldError(ctx, fc) {
7525 ec.Errorf(ctx, "must not be null")
7526 }
7527 return graphql.Null
7528 }
7529 res := resTmp.(bug.Label)
7530 fc.Result = res
7531 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
7532}
7533
7534func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7535 defer func() {
7536 if r := recover(); r != nil {
7537 ec.Error(ctx, ec.Recover(ctx, r))
7538 ret = graphql.Null
7539 }
7540 }()
7541 fc := &graphql.FieldContext{
7542 Object: "Mutation",
7543 Field: field,
7544 Args: nil,
7545 IsMethod: true,
7546 IsResolver: true,
7547 }
7548
7549 ctx = graphql.WithFieldContext(ctx, fc)
7550 rawArgs := field.ArgumentMap(ec.Variables)
7551 args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
7552 if err != nil {
7553 ec.Error(ctx, err)
7554 return graphql.Null
7555 }
7556 fc.Args = args
7557 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7558 ctx = rctx // use context from middleware stack in children
7559 return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
7560 })
7561 if err != nil {
7562 ec.Error(ctx, err)
7563 return graphql.Null
7564 }
7565 if resTmp == nil {
7566 if !graphql.HasFieldError(ctx, fc) {
7567 ec.Errorf(ctx, "must not be null")
7568 }
7569 return graphql.Null
7570 }
7571 res := resTmp.(*models.NewBugPayload)
7572 fc.Result = res
7573 return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
7574}
7575
7576func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7577 defer func() {
7578 if r := recover(); r != nil {
7579 ec.Error(ctx, ec.Recover(ctx, r))
7580 ret = graphql.Null
7581 }
7582 }()
7583 fc := &graphql.FieldContext{
7584 Object: "Mutation",
7585 Field: field,
7586 Args: nil,
7587 IsMethod: true,
7588 IsResolver: true,
7589 }
7590
7591 ctx = graphql.WithFieldContext(ctx, fc)
7592 rawArgs := field.ArgumentMap(ec.Variables)
7593 args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
7594 if err != nil {
7595 ec.Error(ctx, err)
7596 return graphql.Null
7597 }
7598 fc.Args = args
7599 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7600 ctx = rctx // use context from middleware stack in children
7601 return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
7602 })
7603 if err != nil {
7604 ec.Error(ctx, err)
7605 return graphql.Null
7606 }
7607 if resTmp == nil {
7608 if !graphql.HasFieldError(ctx, fc) {
7609 ec.Errorf(ctx, "must not be null")
7610 }
7611 return graphql.Null
7612 }
7613 res := resTmp.(*models.AddCommentPayload)
7614 fc.Result = res
7615 return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
7616}
7617
7618func (ec *executionContext) _Mutation_addCommentAndClose(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7619 defer func() {
7620 if r := recover(); r != nil {
7621 ec.Error(ctx, ec.Recover(ctx, r))
7622 ret = graphql.Null
7623 }
7624 }()
7625 fc := &graphql.FieldContext{
7626 Object: "Mutation",
7627 Field: field,
7628 Args: nil,
7629 IsMethod: true,
7630 IsResolver: true,
7631 }
7632
7633 ctx = graphql.WithFieldContext(ctx, fc)
7634 rawArgs := field.ArgumentMap(ec.Variables)
7635 args, err := ec.field_Mutation_addCommentAndClose_args(ctx, rawArgs)
7636 if err != nil {
7637 ec.Error(ctx, err)
7638 return graphql.Null
7639 }
7640 fc.Args = args
7641 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7642 ctx = rctx // use context from middleware stack in children
7643 return ec.resolvers.Mutation().AddCommentAndClose(rctx, args["input"].(models.AddCommentAndCloseBugInput))
7644 })
7645 if err != nil {
7646 ec.Error(ctx, err)
7647 return graphql.Null
7648 }
7649 if resTmp == nil {
7650 if !graphql.HasFieldError(ctx, fc) {
7651 ec.Errorf(ctx, "must not be null")
7652 }
7653 return graphql.Null
7654 }
7655 res := resTmp.(*models.AddCommentAndCloseBugPayload)
7656 fc.Result = res
7657 return ec.marshalNAddCommentAndCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx, field.Selections, res)
7658}
7659
7660func (ec *executionContext) _Mutation_addCommentAndReopen(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7661 defer func() {
7662 if r := recover(); r != nil {
7663 ec.Error(ctx, ec.Recover(ctx, r))
7664 ret = graphql.Null
7665 }
7666 }()
7667 fc := &graphql.FieldContext{
7668 Object: "Mutation",
7669 Field: field,
7670 Args: nil,
7671 IsMethod: true,
7672 IsResolver: true,
7673 }
7674
7675 ctx = graphql.WithFieldContext(ctx, fc)
7676 rawArgs := field.ArgumentMap(ec.Variables)
7677 args, err := ec.field_Mutation_addCommentAndReopen_args(ctx, rawArgs)
7678 if err != nil {
7679 ec.Error(ctx, err)
7680 return graphql.Null
7681 }
7682 fc.Args = args
7683 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7684 ctx = rctx // use context from middleware stack in children
7685 return ec.resolvers.Mutation().AddCommentAndReopen(rctx, args["input"].(models.AddCommentAndReopenBugInput))
7686 })
7687 if err != nil {
7688 ec.Error(ctx, err)
7689 return graphql.Null
7690 }
7691 if resTmp == nil {
7692 if !graphql.HasFieldError(ctx, fc) {
7693 ec.Errorf(ctx, "must not be null")
7694 }
7695 return graphql.Null
7696 }
7697 res := resTmp.(*models.AddCommentAndReopenBugPayload)
7698 fc.Result = res
7699 return ec.marshalNAddCommentAndReopenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx, field.Selections, res)
7700}
7701
7702func (ec *executionContext) _Mutation_editComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7703 defer func() {
7704 if r := recover(); r != nil {
7705 ec.Error(ctx, ec.Recover(ctx, r))
7706 ret = graphql.Null
7707 }
7708 }()
7709 fc := &graphql.FieldContext{
7710 Object: "Mutation",
7711 Field: field,
7712 Args: nil,
7713 IsMethod: true,
7714 IsResolver: true,
7715 }
7716
7717 ctx = graphql.WithFieldContext(ctx, fc)
7718 rawArgs := field.ArgumentMap(ec.Variables)
7719 args, err := ec.field_Mutation_editComment_args(ctx, rawArgs)
7720 if err != nil {
7721 ec.Error(ctx, err)
7722 return graphql.Null
7723 }
7724 fc.Args = args
7725 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7726 ctx = rctx // use context from middleware stack in children
7727 return ec.resolvers.Mutation().EditComment(rctx, args["input"].(models.EditCommentInput))
7728 })
7729 if err != nil {
7730 ec.Error(ctx, err)
7731 return graphql.Null
7732 }
7733 if resTmp == nil {
7734 if !graphql.HasFieldError(ctx, fc) {
7735 ec.Errorf(ctx, "must not be null")
7736 }
7737 return graphql.Null
7738 }
7739 res := resTmp.(*models.EditCommentPayload)
7740 fc.Result = res
7741 return ec.marshalNEditCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx, field.Selections, res)
7742}
7743
7744func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7745 defer func() {
7746 if r := recover(); r != nil {
7747 ec.Error(ctx, ec.Recover(ctx, r))
7748 ret = graphql.Null
7749 }
7750 }()
7751 fc := &graphql.FieldContext{
7752 Object: "Mutation",
7753 Field: field,
7754 Args: nil,
7755 IsMethod: true,
7756 IsResolver: true,
7757 }
7758
7759 ctx = graphql.WithFieldContext(ctx, fc)
7760 rawArgs := field.ArgumentMap(ec.Variables)
7761 args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
7762 if err != nil {
7763 ec.Error(ctx, err)
7764 return graphql.Null
7765 }
7766 fc.Args = args
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.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
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.(*models.ChangeLabelPayload)
7782 fc.Result = res
7783 return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
7784}
7785
7786func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7787 defer func() {
7788 if r := recover(); r != nil {
7789 ec.Error(ctx, ec.Recover(ctx, r))
7790 ret = graphql.Null
7791 }
7792 }()
7793 fc := &graphql.FieldContext{
7794 Object: "Mutation",
7795 Field: field,
7796 Args: nil,
7797 IsMethod: true,
7798 IsResolver: true,
7799 }
7800
7801 ctx = graphql.WithFieldContext(ctx, fc)
7802 rawArgs := field.ArgumentMap(ec.Variables)
7803 args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
7804 if err != nil {
7805 ec.Error(ctx, err)
7806 return graphql.Null
7807 }
7808 fc.Args = args
7809 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7810 ctx = rctx // use context from middleware stack in children
7811 return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
7812 })
7813 if err != nil {
7814 ec.Error(ctx, err)
7815 return graphql.Null
7816 }
7817 if resTmp == nil {
7818 if !graphql.HasFieldError(ctx, fc) {
7819 ec.Errorf(ctx, "must not be null")
7820 }
7821 return graphql.Null
7822 }
7823 res := resTmp.(*models.OpenBugPayload)
7824 fc.Result = res
7825 return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
7826}
7827
7828func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7829 defer func() {
7830 if r := recover(); r != nil {
7831 ec.Error(ctx, ec.Recover(ctx, r))
7832 ret = graphql.Null
7833 }
7834 }()
7835 fc := &graphql.FieldContext{
7836 Object: "Mutation",
7837 Field: field,
7838 Args: nil,
7839 IsMethod: true,
7840 IsResolver: true,
7841 }
7842
7843 ctx = graphql.WithFieldContext(ctx, fc)
7844 rawArgs := field.ArgumentMap(ec.Variables)
7845 args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
7846 if err != nil {
7847 ec.Error(ctx, err)
7848 return graphql.Null
7849 }
7850 fc.Args = args
7851 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7852 ctx = rctx // use context from middleware stack in children
7853 return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
7854 })
7855 if err != nil {
7856 ec.Error(ctx, err)
7857 return graphql.Null
7858 }
7859 if resTmp == nil {
7860 if !graphql.HasFieldError(ctx, fc) {
7861 ec.Errorf(ctx, "must not be null")
7862 }
7863 return graphql.Null
7864 }
7865 res := resTmp.(*models.CloseBugPayload)
7866 fc.Result = res
7867 return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
7868}
7869
7870func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7871 defer func() {
7872 if r := recover(); r != nil {
7873 ec.Error(ctx, ec.Recover(ctx, r))
7874 ret = graphql.Null
7875 }
7876 }()
7877 fc := &graphql.FieldContext{
7878 Object: "Mutation",
7879 Field: field,
7880 Args: nil,
7881 IsMethod: true,
7882 IsResolver: true,
7883 }
7884
7885 ctx = graphql.WithFieldContext(ctx, fc)
7886 rawArgs := field.ArgumentMap(ec.Variables)
7887 args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
7888 if err != nil {
7889 ec.Error(ctx, err)
7890 return graphql.Null
7891 }
7892 fc.Args = args
7893 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7894 ctx = rctx // use context from middleware stack in children
7895 return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
7896 })
7897 if err != nil {
7898 ec.Error(ctx, err)
7899 return graphql.Null
7900 }
7901 if resTmp == nil {
7902 if !graphql.HasFieldError(ctx, fc) {
7903 ec.Errorf(ctx, "must not be null")
7904 }
7905 return graphql.Null
7906 }
7907 res := resTmp.(*models.SetTitlePayload)
7908 fc.Result = res
7909 return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
7910}
7911
7912func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7913 defer func() {
7914 if r := recover(); r != nil {
7915 ec.Error(ctx, ec.Recover(ctx, r))
7916 ret = graphql.Null
7917 }
7918 }()
7919 fc := &graphql.FieldContext{
7920 Object: "NewBugPayload",
7921 Field: field,
7922 Args: nil,
7923 IsMethod: false,
7924 IsResolver: false,
7925 }
7926
7927 ctx = graphql.WithFieldContext(ctx, fc)
7928 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7929 ctx = rctx // use context from middleware stack in children
7930 return obj.ClientMutationID, nil
7931 })
7932 if err != nil {
7933 ec.Error(ctx, err)
7934 return graphql.Null
7935 }
7936 if resTmp == nil {
7937 return graphql.Null
7938 }
7939 res := resTmp.(*string)
7940 fc.Result = res
7941 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7942}
7943
7944func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7945 defer func() {
7946 if r := recover(); r != nil {
7947 ec.Error(ctx, ec.Recover(ctx, r))
7948 ret = graphql.Null
7949 }
7950 }()
7951 fc := &graphql.FieldContext{
7952 Object: "NewBugPayload",
7953 Field: field,
7954 Args: nil,
7955 IsMethod: false,
7956 IsResolver: false,
7957 }
7958
7959 ctx = graphql.WithFieldContext(ctx, fc)
7960 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7961 ctx = rctx // use context from middleware stack in children
7962 return obj.Bug, nil
7963 })
7964 if err != nil {
7965 ec.Error(ctx, err)
7966 return graphql.Null
7967 }
7968 if resTmp == nil {
7969 if !graphql.HasFieldError(ctx, fc) {
7970 ec.Errorf(ctx, "must not be null")
7971 }
7972 return graphql.Null
7973 }
7974 res := resTmp.(models.BugWrapper)
7975 fc.Result = res
7976 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
7977}
7978
7979func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7980 defer func() {
7981 if r := recover(); r != nil {
7982 ec.Error(ctx, ec.Recover(ctx, r))
7983 ret = graphql.Null
7984 }
7985 }()
7986 fc := &graphql.FieldContext{
7987 Object: "NewBugPayload",
7988 Field: field,
7989 Args: nil,
7990 IsMethod: false,
7991 IsResolver: false,
7992 }
7993
7994 ctx = graphql.WithFieldContext(ctx, fc)
7995 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7996 ctx = rctx // use context from middleware stack in children
7997 return obj.Operation, nil
7998 })
7999 if err != nil {
8000 ec.Error(ctx, err)
8001 return graphql.Null
8002 }
8003 if resTmp == nil {
8004 if !graphql.HasFieldError(ctx, fc) {
8005 ec.Errorf(ctx, "must not be null")
8006 }
8007 return graphql.Null
8008 }
8009 res := resTmp.(*bug.CreateOperation)
8010 fc.Result = res
8011 return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
8012}
8013
8014func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
8015 defer func() {
8016 if r := recover(); r != nil {
8017 ec.Error(ctx, ec.Recover(ctx, r))
8018 ret = graphql.Null
8019 }
8020 }()
8021 fc := &graphql.FieldContext{
8022 Object: "OpenBugPayload",
8023 Field: field,
8024 Args: nil,
8025 IsMethod: false,
8026 IsResolver: false,
8027 }
8028
8029 ctx = graphql.WithFieldContext(ctx, fc)
8030 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8031 ctx = rctx // use context from middleware stack in children
8032 return obj.ClientMutationID, nil
8033 })
8034 if err != nil {
8035 ec.Error(ctx, err)
8036 return graphql.Null
8037 }
8038 if resTmp == nil {
8039 return graphql.Null
8040 }
8041 res := resTmp.(*string)
8042 fc.Result = res
8043 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
8044}
8045
8046func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
8047 defer func() {
8048 if r := recover(); r != nil {
8049 ec.Error(ctx, ec.Recover(ctx, r))
8050 ret = graphql.Null
8051 }
8052 }()
8053 fc := &graphql.FieldContext{
8054 Object: "OpenBugPayload",
8055 Field: field,
8056 Args: nil,
8057 IsMethod: false,
8058 IsResolver: false,
8059 }
8060
8061 ctx = graphql.WithFieldContext(ctx, fc)
8062 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8063 ctx = rctx // use context from middleware stack in children
8064 return obj.Bug, nil
8065 })
8066 if err != nil {
8067 ec.Error(ctx, err)
8068 return graphql.Null
8069 }
8070 if resTmp == nil {
8071 if !graphql.HasFieldError(ctx, fc) {
8072 ec.Errorf(ctx, "must not be null")
8073 }
8074 return graphql.Null
8075 }
8076 res := resTmp.(models.BugWrapper)
8077 fc.Result = res
8078 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
8079}
8080
8081func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
8082 defer func() {
8083 if r := recover(); r != nil {
8084 ec.Error(ctx, ec.Recover(ctx, r))
8085 ret = graphql.Null
8086 }
8087 }()
8088 fc := &graphql.FieldContext{
8089 Object: "OpenBugPayload",
8090 Field: field,
8091 Args: nil,
8092 IsMethod: false,
8093 IsResolver: false,
8094 }
8095
8096 ctx = graphql.WithFieldContext(ctx, fc)
8097 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8098 ctx = rctx // use context from middleware stack in children
8099 return obj.Operation, nil
8100 })
8101 if err != nil {
8102 ec.Error(ctx, err)
8103 return graphql.Null
8104 }
8105 if resTmp == nil {
8106 if !graphql.HasFieldError(ctx, fc) {
8107 ec.Errorf(ctx, "must not be null")
8108 }
8109 return graphql.Null
8110 }
8111 res := resTmp.(*bug.SetStatusOperation)
8112 fc.Result = res
8113 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
8114}
8115
8116func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
8117 defer func() {
8118 if r := recover(); r != nil {
8119 ec.Error(ctx, ec.Recover(ctx, r))
8120 ret = graphql.Null
8121 }
8122 }()
8123 fc := &graphql.FieldContext{
8124 Object: "OperationConnection",
8125 Field: field,
8126 Args: nil,
8127 IsMethod: false,
8128 IsResolver: false,
8129 }
8130
8131 ctx = graphql.WithFieldContext(ctx, fc)
8132 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8133 ctx = rctx // use context from middleware stack in children
8134 return obj.Edges, nil
8135 })
8136 if err != nil {
8137 ec.Error(ctx, err)
8138 return graphql.Null
8139 }
8140 if resTmp == nil {
8141 if !graphql.HasFieldError(ctx, fc) {
8142 ec.Errorf(ctx, "must not be null")
8143 }
8144 return graphql.Null
8145 }
8146 res := resTmp.([]*models.OperationEdge)
8147 fc.Result = res
8148 return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
8149}
8150
8151func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
8152 defer func() {
8153 if r := recover(); r != nil {
8154 ec.Error(ctx, ec.Recover(ctx, r))
8155 ret = graphql.Null
8156 }
8157 }()
8158 fc := &graphql.FieldContext{
8159 Object: "OperationConnection",
8160 Field: field,
8161 Args: nil,
8162 IsMethod: false,
8163 IsResolver: false,
8164 }
8165
8166 ctx = graphql.WithFieldContext(ctx, fc)
8167 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8168 ctx = rctx // use context from middleware stack in children
8169 return obj.Nodes, nil
8170 })
8171 if err != nil {
8172 ec.Error(ctx, err)
8173 return graphql.Null
8174 }
8175 if resTmp == nil {
8176 if !graphql.HasFieldError(ctx, fc) {
8177 ec.Errorf(ctx, "must not be null")
8178 }
8179 return graphql.Null
8180 }
8181 res := resTmp.([]bug.Operation)
8182 fc.Result = res
8183 return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx, field.Selections, res)
8184}
8185
8186func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
8187 defer func() {
8188 if r := recover(); r != nil {
8189 ec.Error(ctx, ec.Recover(ctx, r))
8190 ret = graphql.Null
8191 }
8192 }()
8193 fc := &graphql.FieldContext{
8194 Object: "OperationConnection",
8195 Field: field,
8196 Args: nil,
8197 IsMethod: false,
8198 IsResolver: false,
8199 }
8200
8201 ctx = graphql.WithFieldContext(ctx, fc)
8202 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8203 ctx = rctx // use context from middleware stack in children
8204 return obj.PageInfo, nil
8205 })
8206 if err != nil {
8207 ec.Error(ctx, err)
8208 return graphql.Null
8209 }
8210 if resTmp == nil {
8211 if !graphql.HasFieldError(ctx, fc) {
8212 ec.Errorf(ctx, "must not be null")
8213 }
8214 return graphql.Null
8215 }
8216 res := resTmp.(*models.PageInfo)
8217 fc.Result = res
8218 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
8219}
8220
8221func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
8222 defer func() {
8223 if r := recover(); r != nil {
8224 ec.Error(ctx, ec.Recover(ctx, r))
8225 ret = graphql.Null
8226 }
8227 }()
8228 fc := &graphql.FieldContext{
8229 Object: "OperationConnection",
8230 Field: field,
8231 Args: nil,
8232 IsMethod: false,
8233 IsResolver: false,
8234 }
8235
8236 ctx = graphql.WithFieldContext(ctx, fc)
8237 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8238 ctx = rctx // use context from middleware stack in children
8239 return obj.TotalCount, nil
8240 })
8241 if err != nil {
8242 ec.Error(ctx, err)
8243 return graphql.Null
8244 }
8245 if resTmp == nil {
8246 if !graphql.HasFieldError(ctx, fc) {
8247 ec.Errorf(ctx, "must not be null")
8248 }
8249 return graphql.Null
8250 }
8251 res := resTmp.(int)
8252 fc.Result = res
8253 return ec.marshalNInt2int(ctx, field.Selections, res)
8254}
8255
8256func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
8257 defer func() {
8258 if r := recover(); r != nil {
8259 ec.Error(ctx, ec.Recover(ctx, r))
8260 ret = graphql.Null
8261 }
8262 }()
8263 fc := &graphql.FieldContext{
8264 Object: "OperationEdge",
8265 Field: field,
8266 Args: nil,
8267 IsMethod: false,
8268 IsResolver: false,
8269 }
8270
8271 ctx = graphql.WithFieldContext(ctx, fc)
8272 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8273 ctx = rctx // use context from middleware stack in children
8274 return obj.Cursor, nil
8275 })
8276 if err != nil {
8277 ec.Error(ctx, err)
8278 return graphql.Null
8279 }
8280 if resTmp == nil {
8281 if !graphql.HasFieldError(ctx, fc) {
8282 ec.Errorf(ctx, "must not be null")
8283 }
8284 return graphql.Null
8285 }
8286 res := resTmp.(string)
8287 fc.Result = res
8288 return ec.marshalNString2string(ctx, field.Selections, res)
8289}
8290
8291func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
8292 defer func() {
8293 if r := recover(); r != nil {
8294 ec.Error(ctx, ec.Recover(ctx, r))
8295 ret = graphql.Null
8296 }
8297 }()
8298 fc := &graphql.FieldContext{
8299 Object: "OperationEdge",
8300 Field: field,
8301 Args: nil,
8302 IsMethod: false,
8303 IsResolver: false,
8304 }
8305
8306 ctx = graphql.WithFieldContext(ctx, fc)
8307 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8308 ctx = rctx // use context from middleware stack in children
8309 return obj.Node, nil
8310 })
8311 if err != nil {
8312 ec.Error(ctx, err)
8313 return graphql.Null
8314 }
8315 if resTmp == nil {
8316 if !graphql.HasFieldError(ctx, fc) {
8317 ec.Errorf(ctx, "must not be null")
8318 }
8319 return graphql.Null
8320 }
8321 res := resTmp.(bug.Operation)
8322 fc.Result = res
8323 return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
8324}
8325
8326func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8327 defer func() {
8328 if r := recover(); r != nil {
8329 ec.Error(ctx, ec.Recover(ctx, r))
8330 ret = graphql.Null
8331 }
8332 }()
8333 fc := &graphql.FieldContext{
8334 Object: "PageInfo",
8335 Field: field,
8336 Args: nil,
8337 IsMethod: false,
8338 IsResolver: false,
8339 }
8340
8341 ctx = graphql.WithFieldContext(ctx, fc)
8342 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8343 ctx = rctx // use context from middleware stack in children
8344 return obj.HasNextPage, nil
8345 })
8346 if err != nil {
8347 ec.Error(ctx, err)
8348 return graphql.Null
8349 }
8350 if resTmp == nil {
8351 if !graphql.HasFieldError(ctx, fc) {
8352 ec.Errorf(ctx, "must not be null")
8353 }
8354 return graphql.Null
8355 }
8356 res := resTmp.(bool)
8357 fc.Result = res
8358 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
8359}
8360
8361func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8362 defer func() {
8363 if r := recover(); r != nil {
8364 ec.Error(ctx, ec.Recover(ctx, r))
8365 ret = graphql.Null
8366 }
8367 }()
8368 fc := &graphql.FieldContext{
8369 Object: "PageInfo",
8370 Field: field,
8371 Args: nil,
8372 IsMethod: false,
8373 IsResolver: false,
8374 }
8375
8376 ctx = graphql.WithFieldContext(ctx, fc)
8377 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8378 ctx = rctx // use context from middleware stack in children
8379 return obj.HasPreviousPage, nil
8380 })
8381 if err != nil {
8382 ec.Error(ctx, err)
8383 return graphql.Null
8384 }
8385 if resTmp == nil {
8386 if !graphql.HasFieldError(ctx, fc) {
8387 ec.Errorf(ctx, "must not be null")
8388 }
8389 return graphql.Null
8390 }
8391 res := resTmp.(bool)
8392 fc.Result = res
8393 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
8394}
8395
8396func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8397 defer func() {
8398 if r := recover(); r != nil {
8399 ec.Error(ctx, ec.Recover(ctx, r))
8400 ret = graphql.Null
8401 }
8402 }()
8403 fc := &graphql.FieldContext{
8404 Object: "PageInfo",
8405 Field: field,
8406 Args: nil,
8407 IsMethod: false,
8408 IsResolver: false,
8409 }
8410
8411 ctx = graphql.WithFieldContext(ctx, fc)
8412 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8413 ctx = rctx // use context from middleware stack in children
8414 return obj.StartCursor, nil
8415 })
8416 if err != nil {
8417 ec.Error(ctx, err)
8418 return graphql.Null
8419 }
8420 if resTmp == nil {
8421 if !graphql.HasFieldError(ctx, fc) {
8422 ec.Errorf(ctx, "must not be null")
8423 }
8424 return graphql.Null
8425 }
8426 res := resTmp.(string)
8427 fc.Result = res
8428 return ec.marshalNString2string(ctx, field.Selections, res)
8429}
8430
8431func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8432 defer func() {
8433 if r := recover(); r != nil {
8434 ec.Error(ctx, ec.Recover(ctx, r))
8435 ret = graphql.Null
8436 }
8437 }()
8438 fc := &graphql.FieldContext{
8439 Object: "PageInfo",
8440 Field: field,
8441 Args: nil,
8442 IsMethod: false,
8443 IsResolver: false,
8444 }
8445
8446 ctx = graphql.WithFieldContext(ctx, fc)
8447 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8448 ctx = rctx // use context from middleware stack in children
8449 return obj.EndCursor, nil
8450 })
8451 if err != nil {
8452 ec.Error(ctx, err)
8453 return graphql.Null
8454 }
8455 if resTmp == nil {
8456 if !graphql.HasFieldError(ctx, fc) {
8457 ec.Errorf(ctx, "must not be null")
8458 }
8459 return graphql.Null
8460 }
8461 res := resTmp.(string)
8462 fc.Result = res
8463 return ec.marshalNString2string(ctx, field.Selections, res)
8464}
8465
8466func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8467 defer func() {
8468 if r := recover(); r != nil {
8469 ec.Error(ctx, ec.Recover(ctx, r))
8470 ret = graphql.Null
8471 }
8472 }()
8473 fc := &graphql.FieldContext{
8474 Object: "Query",
8475 Field: field,
8476 Args: nil,
8477 IsMethod: true,
8478 IsResolver: true,
8479 }
8480
8481 ctx = graphql.WithFieldContext(ctx, fc)
8482 rawArgs := field.ArgumentMap(ec.Variables)
8483 args, err := ec.field_Query_repository_args(ctx, rawArgs)
8484 if err != nil {
8485 ec.Error(ctx, err)
8486 return graphql.Null
8487 }
8488 fc.Args = args
8489 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8490 ctx = rctx // use context from middleware stack in children
8491 return ec.resolvers.Query().Repository(rctx, args["ref"].(*string))
8492 })
8493 if err != nil {
8494 ec.Error(ctx, err)
8495 return graphql.Null
8496 }
8497 if resTmp == nil {
8498 return graphql.Null
8499 }
8500 res := resTmp.(*models.Repository)
8501 fc.Result = res
8502 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
8503}
8504
8505func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8506 defer func() {
8507 if r := recover(); r != nil {
8508 ec.Error(ctx, ec.Recover(ctx, r))
8509 ret = graphql.Null
8510 }
8511 }()
8512 fc := &graphql.FieldContext{
8513 Object: "Query",
8514 Field: field,
8515 Args: nil,
8516 IsMethod: true,
8517 IsResolver: false,
8518 }
8519
8520 ctx = graphql.WithFieldContext(ctx, fc)
8521 rawArgs := field.ArgumentMap(ec.Variables)
8522 args, err := ec.field_Query___type_args(ctx, rawArgs)
8523 if err != nil {
8524 ec.Error(ctx, err)
8525 return graphql.Null
8526 }
8527 fc.Args = args
8528 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8529 ctx = rctx // use context from middleware stack in children
8530 return ec.introspectType(args["name"].(string))
8531 })
8532 if err != nil {
8533 ec.Error(ctx, err)
8534 return graphql.Null
8535 }
8536 if resTmp == nil {
8537 return graphql.Null
8538 }
8539 res := resTmp.(*introspection.Type)
8540 fc.Result = res
8541 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
8542}
8543
8544func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8545 defer func() {
8546 if r := recover(); r != nil {
8547 ec.Error(ctx, ec.Recover(ctx, r))
8548 ret = graphql.Null
8549 }
8550 }()
8551 fc := &graphql.FieldContext{
8552 Object: "Query",
8553 Field: field,
8554 Args: nil,
8555 IsMethod: true,
8556 IsResolver: false,
8557 }
8558
8559 ctx = graphql.WithFieldContext(ctx, fc)
8560 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8561 ctx = rctx // use context from middleware stack in children
8562 return ec.introspectSchema()
8563 })
8564 if err != nil {
8565 ec.Error(ctx, err)
8566 return graphql.Null
8567 }
8568 if resTmp == nil {
8569 return graphql.Null
8570 }
8571 res := resTmp.(*introspection.Schema)
8572 fc.Result = res
8573 return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
8574}
8575
8576func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8577 defer func() {
8578 if r := recover(); r != nil {
8579 ec.Error(ctx, ec.Recover(ctx, r))
8580 ret = graphql.Null
8581 }
8582 }()
8583 fc := &graphql.FieldContext{
8584 Object: "Repository",
8585 Field: field,
8586 Args: nil,
8587 IsMethod: true,
8588 IsResolver: true,
8589 }
8590
8591 ctx = graphql.WithFieldContext(ctx, fc)
8592 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8593 ctx = rctx // use context from middleware stack in children
8594 return ec.resolvers.Repository().Name(rctx, obj)
8595 })
8596 if err != nil {
8597 ec.Error(ctx, err)
8598 return graphql.Null
8599 }
8600 if resTmp == nil {
8601 return graphql.Null
8602 }
8603 res := resTmp.(*string)
8604 fc.Result = res
8605 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
8606}
8607
8608func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8609 defer func() {
8610 if r := recover(); r != nil {
8611 ec.Error(ctx, ec.Recover(ctx, r))
8612 ret = graphql.Null
8613 }
8614 }()
8615 fc := &graphql.FieldContext{
8616 Object: "Repository",
8617 Field: field,
8618 Args: nil,
8619 IsMethod: true,
8620 IsResolver: true,
8621 }
8622
8623 ctx = graphql.WithFieldContext(ctx, fc)
8624 rawArgs := field.ArgumentMap(ec.Variables)
8625 args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
8626 if err != nil {
8627 ec.Error(ctx, err)
8628 return graphql.Null
8629 }
8630 fc.Args = args
8631 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8632 ctx = rctx // use context from middleware stack in children
8633 return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
8634 })
8635 if err != nil {
8636 ec.Error(ctx, err)
8637 return graphql.Null
8638 }
8639 if resTmp == nil {
8640 if !graphql.HasFieldError(ctx, fc) {
8641 ec.Errorf(ctx, "must not be null")
8642 }
8643 return graphql.Null
8644 }
8645 res := resTmp.(*models.BugConnection)
8646 fc.Result = res
8647 return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
8648}
8649
8650func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8651 defer func() {
8652 if r := recover(); r != nil {
8653 ec.Error(ctx, ec.Recover(ctx, r))
8654 ret = graphql.Null
8655 }
8656 }()
8657 fc := &graphql.FieldContext{
8658 Object: "Repository",
8659 Field: field,
8660 Args: nil,
8661 IsMethod: true,
8662 IsResolver: true,
8663 }
8664
8665 ctx = graphql.WithFieldContext(ctx, fc)
8666 rawArgs := field.ArgumentMap(ec.Variables)
8667 args, err := ec.field_Repository_bug_args(ctx, rawArgs)
8668 if err != nil {
8669 ec.Error(ctx, err)
8670 return graphql.Null
8671 }
8672 fc.Args = args
8673 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8674 ctx = rctx // use context from middleware stack in children
8675 return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
8676 })
8677 if err != nil {
8678 ec.Error(ctx, err)
8679 return graphql.Null
8680 }
8681 if resTmp == nil {
8682 return graphql.Null
8683 }
8684 res := resTmp.(models.BugWrapper)
8685 fc.Result = res
8686 return ec.marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
8687}
8688
8689func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8690 defer func() {
8691 if r := recover(); r != nil {
8692 ec.Error(ctx, ec.Recover(ctx, r))
8693 ret = graphql.Null
8694 }
8695 }()
8696 fc := &graphql.FieldContext{
8697 Object: "Repository",
8698 Field: field,
8699 Args: nil,
8700 IsMethod: true,
8701 IsResolver: true,
8702 }
8703
8704 ctx = graphql.WithFieldContext(ctx, fc)
8705 rawArgs := field.ArgumentMap(ec.Variables)
8706 args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
8707 if err != nil {
8708 ec.Error(ctx, err)
8709 return graphql.Null
8710 }
8711 fc.Args = args
8712 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8713 ctx = rctx // use context from middleware stack in children
8714 return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8715 })
8716 if err != nil {
8717 ec.Error(ctx, err)
8718 return graphql.Null
8719 }
8720 if resTmp == nil {
8721 if !graphql.HasFieldError(ctx, fc) {
8722 ec.Errorf(ctx, "must not be null")
8723 }
8724 return graphql.Null
8725 }
8726 res := resTmp.(*models.IdentityConnection)
8727 fc.Result = res
8728 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
8729}
8730
8731func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8732 defer func() {
8733 if r := recover(); r != nil {
8734 ec.Error(ctx, ec.Recover(ctx, r))
8735 ret = graphql.Null
8736 }
8737 }()
8738 fc := &graphql.FieldContext{
8739 Object: "Repository",
8740 Field: field,
8741 Args: nil,
8742 IsMethod: true,
8743 IsResolver: true,
8744 }
8745
8746 ctx = graphql.WithFieldContext(ctx, fc)
8747 rawArgs := field.ArgumentMap(ec.Variables)
8748 args, err := ec.field_Repository_identity_args(ctx, rawArgs)
8749 if err != nil {
8750 ec.Error(ctx, err)
8751 return graphql.Null
8752 }
8753 fc.Args = args
8754 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8755 ctx = rctx // use context from middleware stack in children
8756 return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
8757 })
8758 if err != nil {
8759 ec.Error(ctx, err)
8760 return graphql.Null
8761 }
8762 if resTmp == nil {
8763 return graphql.Null
8764 }
8765 res := resTmp.(models.IdentityWrapper)
8766 fc.Result = res
8767 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8768}
8769
8770func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8771 defer func() {
8772 if r := recover(); r != nil {
8773 ec.Error(ctx, ec.Recover(ctx, r))
8774 ret = graphql.Null
8775 }
8776 }()
8777 fc := &graphql.FieldContext{
8778 Object: "Repository",
8779 Field: field,
8780 Args: nil,
8781 IsMethod: true,
8782 IsResolver: true,
8783 }
8784
8785 ctx = graphql.WithFieldContext(ctx, fc)
8786 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8787 ctx = rctx // use context from middleware stack in children
8788 return ec.resolvers.Repository().UserIdentity(rctx, obj)
8789 })
8790 if err != nil {
8791 ec.Error(ctx, err)
8792 return graphql.Null
8793 }
8794 if resTmp == nil {
8795 return graphql.Null
8796 }
8797 res := resTmp.(models.IdentityWrapper)
8798 fc.Result = res
8799 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8800}
8801
8802func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8803 defer func() {
8804 if r := recover(); r != nil {
8805 ec.Error(ctx, ec.Recover(ctx, r))
8806 ret = graphql.Null
8807 }
8808 }()
8809 fc := &graphql.FieldContext{
8810 Object: "Repository",
8811 Field: field,
8812 Args: nil,
8813 IsMethod: true,
8814 IsResolver: true,
8815 }
8816
8817 ctx = graphql.WithFieldContext(ctx, fc)
8818 rawArgs := field.ArgumentMap(ec.Variables)
8819 args, err := ec.field_Repository_validLabels_args(ctx, rawArgs)
8820 if err != nil {
8821 ec.Error(ctx, err)
8822 return graphql.Null
8823 }
8824 fc.Args = args
8825 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8826 ctx = rctx // use context from middleware stack in children
8827 return ec.resolvers.Repository().ValidLabels(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8828 })
8829 if err != nil {
8830 ec.Error(ctx, err)
8831 return graphql.Null
8832 }
8833 if resTmp == nil {
8834 if !graphql.HasFieldError(ctx, fc) {
8835 ec.Errorf(ctx, "must not be null")
8836 }
8837 return graphql.Null
8838 }
8839 res := resTmp.(*models.LabelConnection)
8840 fc.Result = res
8841 return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
8842}
8843
8844func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8845 defer func() {
8846 if r := recover(); r != nil {
8847 ec.Error(ctx, ec.Recover(ctx, r))
8848 ret = graphql.Null
8849 }
8850 }()
8851 fc := &graphql.FieldContext{
8852 Object: "SetStatusOperation",
8853 Field: field,
8854 Args: nil,
8855 IsMethod: true,
8856 IsResolver: true,
8857 }
8858
8859 ctx = graphql.WithFieldContext(ctx, fc)
8860 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8861 ctx = rctx // use context from middleware stack in children
8862 return ec.resolvers.SetStatusOperation().ID(rctx, obj)
8863 })
8864 if err != nil {
8865 ec.Error(ctx, err)
8866 return graphql.Null
8867 }
8868 if resTmp == nil {
8869 if !graphql.HasFieldError(ctx, fc) {
8870 ec.Errorf(ctx, "must not be null")
8871 }
8872 return graphql.Null
8873 }
8874 res := resTmp.(string)
8875 fc.Result = res
8876 return ec.marshalNString2string(ctx, field.Selections, res)
8877}
8878
8879func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8880 defer func() {
8881 if r := recover(); r != nil {
8882 ec.Error(ctx, ec.Recover(ctx, r))
8883 ret = graphql.Null
8884 }
8885 }()
8886 fc := &graphql.FieldContext{
8887 Object: "SetStatusOperation",
8888 Field: field,
8889 Args: nil,
8890 IsMethod: true,
8891 IsResolver: true,
8892 }
8893
8894 ctx = graphql.WithFieldContext(ctx, fc)
8895 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8896 ctx = rctx // use context from middleware stack in children
8897 return ec.resolvers.SetStatusOperation().Author(rctx, obj)
8898 })
8899 if err != nil {
8900 ec.Error(ctx, err)
8901 return graphql.Null
8902 }
8903 if resTmp == nil {
8904 if !graphql.HasFieldError(ctx, fc) {
8905 ec.Errorf(ctx, "must not be null")
8906 }
8907 return graphql.Null
8908 }
8909 res := resTmp.(models.IdentityWrapper)
8910 fc.Result = res
8911 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8912}
8913
8914func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8915 defer func() {
8916 if r := recover(); r != nil {
8917 ec.Error(ctx, ec.Recover(ctx, r))
8918 ret = graphql.Null
8919 }
8920 }()
8921 fc := &graphql.FieldContext{
8922 Object: "SetStatusOperation",
8923 Field: field,
8924 Args: nil,
8925 IsMethod: true,
8926 IsResolver: true,
8927 }
8928
8929 ctx = graphql.WithFieldContext(ctx, fc)
8930 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8931 ctx = rctx // use context from middleware stack in children
8932 return ec.resolvers.SetStatusOperation().Date(rctx, obj)
8933 })
8934 if err != nil {
8935 ec.Error(ctx, err)
8936 return graphql.Null
8937 }
8938 if resTmp == nil {
8939 if !graphql.HasFieldError(ctx, fc) {
8940 ec.Errorf(ctx, "must not be null")
8941 }
8942 return graphql.Null
8943 }
8944 res := resTmp.(*time.Time)
8945 fc.Result = res
8946 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8947}
8948
8949func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8950 defer func() {
8951 if r := recover(); r != nil {
8952 ec.Error(ctx, ec.Recover(ctx, r))
8953 ret = graphql.Null
8954 }
8955 }()
8956 fc := &graphql.FieldContext{
8957 Object: "SetStatusOperation",
8958 Field: field,
8959 Args: nil,
8960 IsMethod: true,
8961 IsResolver: true,
8962 }
8963
8964 ctx = graphql.WithFieldContext(ctx, fc)
8965 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8966 ctx = rctx // use context from middleware stack in children
8967 return ec.resolvers.SetStatusOperation().Status(rctx, obj)
8968 })
8969 if err != nil {
8970 ec.Error(ctx, err)
8971 return graphql.Null
8972 }
8973 if resTmp == nil {
8974 if !graphql.HasFieldError(ctx, fc) {
8975 ec.Errorf(ctx, "must not be null")
8976 }
8977 return graphql.Null
8978 }
8979 res := resTmp.(models.Status)
8980 fc.Result = res
8981 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8982}
8983
8984func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8985 defer func() {
8986 if r := recover(); r != nil {
8987 ec.Error(ctx, ec.Recover(ctx, r))
8988 ret = graphql.Null
8989 }
8990 }()
8991 fc := &graphql.FieldContext{
8992 Object: "SetStatusTimelineItem",
8993 Field: field,
8994 Args: nil,
8995 IsMethod: true,
8996 IsResolver: true,
8997 }
8998
8999 ctx = graphql.WithFieldContext(ctx, fc)
9000 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9001 ctx = rctx // use context from middleware stack in children
9002 return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
9003 })
9004 if err != nil {
9005 ec.Error(ctx, err)
9006 return graphql.Null
9007 }
9008 if resTmp == nil {
9009 if !graphql.HasFieldError(ctx, fc) {
9010 ec.Errorf(ctx, "must not be null")
9011 }
9012 return graphql.Null
9013 }
9014 res := resTmp.(string)
9015 fc.Result = res
9016 return ec.marshalNString2string(ctx, field.Selections, res)
9017}
9018
9019func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
9020 defer func() {
9021 if r := recover(); r != nil {
9022 ec.Error(ctx, ec.Recover(ctx, r))
9023 ret = graphql.Null
9024 }
9025 }()
9026 fc := &graphql.FieldContext{
9027 Object: "SetStatusTimelineItem",
9028 Field: field,
9029 Args: nil,
9030 IsMethod: true,
9031 IsResolver: true,
9032 }
9033
9034 ctx = graphql.WithFieldContext(ctx, fc)
9035 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9036 ctx = rctx // use context from middleware stack in children
9037 return ec.resolvers.SetStatusTimelineItem().Author(rctx, obj)
9038 })
9039 if err != nil {
9040 ec.Error(ctx, err)
9041 return graphql.Null
9042 }
9043 if resTmp == nil {
9044 if !graphql.HasFieldError(ctx, fc) {
9045 ec.Errorf(ctx, "must not be null")
9046 }
9047 return graphql.Null
9048 }
9049 res := resTmp.(models.IdentityWrapper)
9050 fc.Result = res
9051 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
9052}
9053
9054func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
9055 defer func() {
9056 if r := recover(); r != nil {
9057 ec.Error(ctx, ec.Recover(ctx, r))
9058 ret = graphql.Null
9059 }
9060 }()
9061 fc := &graphql.FieldContext{
9062 Object: "SetStatusTimelineItem",
9063 Field: field,
9064 Args: nil,
9065 IsMethod: true,
9066 IsResolver: true,
9067 }
9068
9069 ctx = graphql.WithFieldContext(ctx, fc)
9070 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9071 ctx = rctx // use context from middleware stack in children
9072 return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
9073 })
9074 if err != nil {
9075 ec.Error(ctx, err)
9076 return graphql.Null
9077 }
9078 if resTmp == nil {
9079 if !graphql.HasFieldError(ctx, fc) {
9080 ec.Errorf(ctx, "must not be null")
9081 }
9082 return graphql.Null
9083 }
9084 res := resTmp.(*time.Time)
9085 fc.Result = res
9086 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
9087}
9088
9089func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
9090 defer func() {
9091 if r := recover(); r != nil {
9092 ec.Error(ctx, ec.Recover(ctx, r))
9093 ret = graphql.Null
9094 }
9095 }()
9096 fc := &graphql.FieldContext{
9097 Object: "SetStatusTimelineItem",
9098 Field: field,
9099 Args: nil,
9100 IsMethod: true,
9101 IsResolver: true,
9102 }
9103
9104 ctx = graphql.WithFieldContext(ctx, fc)
9105 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9106 ctx = rctx // use context from middleware stack in children
9107 return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
9108 })
9109 if err != nil {
9110 ec.Error(ctx, err)
9111 return graphql.Null
9112 }
9113 if resTmp == nil {
9114 if !graphql.HasFieldError(ctx, fc) {
9115 ec.Errorf(ctx, "must not be null")
9116 }
9117 return graphql.Null
9118 }
9119 res := resTmp.(models.Status)
9120 fc.Result = res
9121 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
9122}
9123
9124func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
9125 defer func() {
9126 if r := recover(); r != nil {
9127 ec.Error(ctx, ec.Recover(ctx, r))
9128 ret = graphql.Null
9129 }
9130 }()
9131 fc := &graphql.FieldContext{
9132 Object: "SetTitleOperation",
9133 Field: field,
9134 Args: nil,
9135 IsMethod: true,
9136 IsResolver: true,
9137 }
9138
9139 ctx = graphql.WithFieldContext(ctx, fc)
9140 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9141 ctx = rctx // use context from middleware stack in children
9142 return ec.resolvers.SetTitleOperation().ID(rctx, obj)
9143 })
9144 if err != nil {
9145 ec.Error(ctx, err)
9146 return graphql.Null
9147 }
9148 if resTmp == nil {
9149 if !graphql.HasFieldError(ctx, fc) {
9150 ec.Errorf(ctx, "must not be null")
9151 }
9152 return graphql.Null
9153 }
9154 res := resTmp.(string)
9155 fc.Result = res
9156 return ec.marshalNString2string(ctx, field.Selections, res)
9157}
9158
9159func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
9160 defer func() {
9161 if r := recover(); r != nil {
9162 ec.Error(ctx, ec.Recover(ctx, r))
9163 ret = graphql.Null
9164 }
9165 }()
9166 fc := &graphql.FieldContext{
9167 Object: "SetTitleOperation",
9168 Field: field,
9169 Args: nil,
9170 IsMethod: true,
9171 IsResolver: true,
9172 }
9173
9174 ctx = graphql.WithFieldContext(ctx, fc)
9175 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9176 ctx = rctx // use context from middleware stack in children
9177 return ec.resolvers.SetTitleOperation().Author(rctx, obj)
9178 })
9179 if err != nil {
9180 ec.Error(ctx, err)
9181 return graphql.Null
9182 }
9183 if resTmp == nil {
9184 if !graphql.HasFieldError(ctx, fc) {
9185 ec.Errorf(ctx, "must not be null")
9186 }
9187 return graphql.Null
9188 }
9189 res := resTmp.(models.IdentityWrapper)
9190 fc.Result = res
9191 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
9192}
9193
9194func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
9195 defer func() {
9196 if r := recover(); r != nil {
9197 ec.Error(ctx, ec.Recover(ctx, r))
9198 ret = graphql.Null
9199 }
9200 }()
9201 fc := &graphql.FieldContext{
9202 Object: "SetTitleOperation",
9203 Field: field,
9204 Args: nil,
9205 IsMethod: true,
9206 IsResolver: true,
9207 }
9208
9209 ctx = graphql.WithFieldContext(ctx, fc)
9210 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9211 ctx = rctx // use context from middleware stack in children
9212 return ec.resolvers.SetTitleOperation().Date(rctx, obj)
9213 })
9214 if err != nil {
9215 ec.Error(ctx, err)
9216 return graphql.Null
9217 }
9218 if resTmp == nil {
9219 if !graphql.HasFieldError(ctx, fc) {
9220 ec.Errorf(ctx, "must not be null")
9221 }
9222 return graphql.Null
9223 }
9224 res := resTmp.(*time.Time)
9225 fc.Result = res
9226 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
9227}
9228
9229func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
9230 defer func() {
9231 if r := recover(); r != nil {
9232 ec.Error(ctx, ec.Recover(ctx, r))
9233 ret = graphql.Null
9234 }
9235 }()
9236 fc := &graphql.FieldContext{
9237 Object: "SetTitleOperation",
9238 Field: field,
9239 Args: nil,
9240 IsMethod: false,
9241 IsResolver: false,
9242 }
9243
9244 ctx = graphql.WithFieldContext(ctx, fc)
9245 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9246 ctx = rctx // use context from middleware stack in children
9247 return obj.Title, nil
9248 })
9249 if err != nil {
9250 ec.Error(ctx, err)
9251 return graphql.Null
9252 }
9253 if resTmp == nil {
9254 if !graphql.HasFieldError(ctx, fc) {
9255 ec.Errorf(ctx, "must not be null")
9256 }
9257 return graphql.Null
9258 }
9259 res := resTmp.(string)
9260 fc.Result = res
9261 return ec.marshalNString2string(ctx, field.Selections, res)
9262}
9263
9264func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
9265 defer func() {
9266 if r := recover(); r != nil {
9267 ec.Error(ctx, ec.Recover(ctx, r))
9268 ret = graphql.Null
9269 }
9270 }()
9271 fc := &graphql.FieldContext{
9272 Object: "SetTitleOperation",
9273 Field: field,
9274 Args: nil,
9275 IsMethod: false,
9276 IsResolver: false,
9277 }
9278
9279 ctx = graphql.WithFieldContext(ctx, fc)
9280 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9281 ctx = rctx // use context from middleware stack in children
9282 return obj.Was, nil
9283 })
9284 if err != nil {
9285 ec.Error(ctx, err)
9286 return graphql.Null
9287 }
9288 if resTmp == nil {
9289 if !graphql.HasFieldError(ctx, fc) {
9290 ec.Errorf(ctx, "must not be null")
9291 }
9292 return graphql.Null
9293 }
9294 res := resTmp.(string)
9295 fc.Result = res
9296 return ec.marshalNString2string(ctx, field.Selections, res)
9297}
9298
9299func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
9300 defer func() {
9301 if r := recover(); r != nil {
9302 ec.Error(ctx, ec.Recover(ctx, r))
9303 ret = graphql.Null
9304 }
9305 }()
9306 fc := &graphql.FieldContext{
9307 Object: "SetTitlePayload",
9308 Field: field,
9309 Args: nil,
9310 IsMethod: false,
9311 IsResolver: false,
9312 }
9313
9314 ctx = graphql.WithFieldContext(ctx, fc)
9315 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9316 ctx = rctx // use context from middleware stack in children
9317 return obj.ClientMutationID, nil
9318 })
9319 if err != nil {
9320 ec.Error(ctx, err)
9321 return graphql.Null
9322 }
9323 if resTmp == nil {
9324 return graphql.Null
9325 }
9326 res := resTmp.(*string)
9327 fc.Result = res
9328 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9329}
9330
9331func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
9332 defer func() {
9333 if r := recover(); r != nil {
9334 ec.Error(ctx, ec.Recover(ctx, r))
9335 ret = graphql.Null
9336 }
9337 }()
9338 fc := &graphql.FieldContext{
9339 Object: "SetTitlePayload",
9340 Field: field,
9341 Args: nil,
9342 IsMethod: false,
9343 IsResolver: false,
9344 }
9345
9346 ctx = graphql.WithFieldContext(ctx, fc)
9347 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9348 ctx = rctx // use context from middleware stack in children
9349 return obj.Bug, nil
9350 })
9351 if err != nil {
9352 ec.Error(ctx, err)
9353 return graphql.Null
9354 }
9355 if resTmp == nil {
9356 if !graphql.HasFieldError(ctx, fc) {
9357 ec.Errorf(ctx, "must not be null")
9358 }
9359 return graphql.Null
9360 }
9361 res := resTmp.(models.BugWrapper)
9362 fc.Result = res
9363 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
9364}
9365
9366func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
9367 defer func() {
9368 if r := recover(); r != nil {
9369 ec.Error(ctx, ec.Recover(ctx, r))
9370 ret = graphql.Null
9371 }
9372 }()
9373 fc := &graphql.FieldContext{
9374 Object: "SetTitlePayload",
9375 Field: field,
9376 Args: nil,
9377 IsMethod: false,
9378 IsResolver: false,
9379 }
9380
9381 ctx = graphql.WithFieldContext(ctx, fc)
9382 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9383 ctx = rctx // use context from middleware stack in children
9384 return obj.Operation, nil
9385 })
9386 if err != nil {
9387 ec.Error(ctx, err)
9388 return graphql.Null
9389 }
9390 if resTmp == nil {
9391 if !graphql.HasFieldError(ctx, fc) {
9392 ec.Errorf(ctx, "must not be null")
9393 }
9394 return graphql.Null
9395 }
9396 res := resTmp.(*bug.SetTitleOperation)
9397 fc.Result = res
9398 return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
9399}
9400
9401func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9402 defer func() {
9403 if r := recover(); r != nil {
9404 ec.Error(ctx, ec.Recover(ctx, r))
9405 ret = graphql.Null
9406 }
9407 }()
9408 fc := &graphql.FieldContext{
9409 Object: "SetTitleTimelineItem",
9410 Field: field,
9411 Args: nil,
9412 IsMethod: true,
9413 IsResolver: true,
9414 }
9415
9416 ctx = graphql.WithFieldContext(ctx, fc)
9417 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9418 ctx = rctx // use context from middleware stack in children
9419 return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
9420 })
9421 if err != nil {
9422 ec.Error(ctx, err)
9423 return graphql.Null
9424 }
9425 if resTmp == nil {
9426 if !graphql.HasFieldError(ctx, fc) {
9427 ec.Errorf(ctx, "must not be null")
9428 }
9429 return graphql.Null
9430 }
9431 res := resTmp.(string)
9432 fc.Result = res
9433 return ec.marshalNString2string(ctx, field.Selections, res)
9434}
9435
9436func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9437 defer func() {
9438 if r := recover(); r != nil {
9439 ec.Error(ctx, ec.Recover(ctx, r))
9440 ret = graphql.Null
9441 }
9442 }()
9443 fc := &graphql.FieldContext{
9444 Object: "SetTitleTimelineItem",
9445 Field: field,
9446 Args: nil,
9447 IsMethod: true,
9448 IsResolver: true,
9449 }
9450
9451 ctx = graphql.WithFieldContext(ctx, fc)
9452 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9453 ctx = rctx // use context from middleware stack in children
9454 return ec.resolvers.SetTitleTimelineItem().Author(rctx, obj)
9455 })
9456 if err != nil {
9457 ec.Error(ctx, err)
9458 return graphql.Null
9459 }
9460 if resTmp == nil {
9461 if !graphql.HasFieldError(ctx, fc) {
9462 ec.Errorf(ctx, "must not be null")
9463 }
9464 return graphql.Null
9465 }
9466 res := resTmp.(models.IdentityWrapper)
9467 fc.Result = res
9468 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
9469}
9470
9471func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9472 defer func() {
9473 if r := recover(); r != nil {
9474 ec.Error(ctx, ec.Recover(ctx, r))
9475 ret = graphql.Null
9476 }
9477 }()
9478 fc := &graphql.FieldContext{
9479 Object: "SetTitleTimelineItem",
9480 Field: field,
9481 Args: nil,
9482 IsMethod: true,
9483 IsResolver: true,
9484 }
9485
9486 ctx = graphql.WithFieldContext(ctx, fc)
9487 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9488 ctx = rctx // use context from middleware stack in children
9489 return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
9490 })
9491 if err != nil {
9492 ec.Error(ctx, err)
9493 return graphql.Null
9494 }
9495 if resTmp == nil {
9496 if !graphql.HasFieldError(ctx, fc) {
9497 ec.Errorf(ctx, "must not be null")
9498 }
9499 return graphql.Null
9500 }
9501 res := resTmp.(*time.Time)
9502 fc.Result = res
9503 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
9504}
9505
9506func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9507 defer func() {
9508 if r := recover(); r != nil {
9509 ec.Error(ctx, ec.Recover(ctx, r))
9510 ret = graphql.Null
9511 }
9512 }()
9513 fc := &graphql.FieldContext{
9514 Object: "SetTitleTimelineItem",
9515 Field: field,
9516 Args: nil,
9517 IsMethod: false,
9518 IsResolver: false,
9519 }
9520
9521 ctx = graphql.WithFieldContext(ctx, fc)
9522 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9523 ctx = rctx // use context from middleware stack in children
9524 return obj.Title, nil
9525 })
9526 if err != nil {
9527 ec.Error(ctx, err)
9528 return graphql.Null
9529 }
9530 if resTmp == nil {
9531 if !graphql.HasFieldError(ctx, fc) {
9532 ec.Errorf(ctx, "must not be null")
9533 }
9534 return graphql.Null
9535 }
9536 res := resTmp.(string)
9537 fc.Result = res
9538 return ec.marshalNString2string(ctx, field.Selections, res)
9539}
9540
9541func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9542 defer func() {
9543 if r := recover(); r != nil {
9544 ec.Error(ctx, ec.Recover(ctx, r))
9545 ret = graphql.Null
9546 }
9547 }()
9548 fc := &graphql.FieldContext{
9549 Object: "SetTitleTimelineItem",
9550 Field: field,
9551 Args: nil,
9552 IsMethod: false,
9553 IsResolver: false,
9554 }
9555
9556 ctx = graphql.WithFieldContext(ctx, fc)
9557 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9558 ctx = rctx // use context from middleware stack in children
9559 return obj.Was, nil
9560 })
9561 if err != nil {
9562 ec.Error(ctx, err)
9563 return graphql.Null
9564 }
9565 if resTmp == nil {
9566 if !graphql.HasFieldError(ctx, fc) {
9567 ec.Errorf(ctx, "must not be null")
9568 }
9569 return graphql.Null
9570 }
9571 res := resTmp.(string)
9572 fc.Result = res
9573 return ec.marshalNString2string(ctx, field.Selections, res)
9574}
9575
9576func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9577 defer func() {
9578 if r := recover(); r != nil {
9579 ec.Error(ctx, ec.Recover(ctx, r))
9580 ret = graphql.Null
9581 }
9582 }()
9583 fc := &graphql.FieldContext{
9584 Object: "TimelineItemConnection",
9585 Field: field,
9586 Args: nil,
9587 IsMethod: false,
9588 IsResolver: false,
9589 }
9590
9591 ctx = graphql.WithFieldContext(ctx, fc)
9592 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9593 ctx = rctx // use context from middleware stack in children
9594 return obj.Edges, nil
9595 })
9596 if err != nil {
9597 ec.Error(ctx, err)
9598 return graphql.Null
9599 }
9600 if resTmp == nil {
9601 if !graphql.HasFieldError(ctx, fc) {
9602 ec.Errorf(ctx, "must not be null")
9603 }
9604 return graphql.Null
9605 }
9606 res := resTmp.([]*models.TimelineItemEdge)
9607 fc.Result = res
9608 return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx, field.Selections, res)
9609}
9610
9611func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9612 defer func() {
9613 if r := recover(); r != nil {
9614 ec.Error(ctx, ec.Recover(ctx, r))
9615 ret = graphql.Null
9616 }
9617 }()
9618 fc := &graphql.FieldContext{
9619 Object: "TimelineItemConnection",
9620 Field: field,
9621 Args: nil,
9622 IsMethod: false,
9623 IsResolver: false,
9624 }
9625
9626 ctx = graphql.WithFieldContext(ctx, fc)
9627 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9628 ctx = rctx // use context from middleware stack in children
9629 return obj.Nodes, nil
9630 })
9631 if err != nil {
9632 ec.Error(ctx, err)
9633 return graphql.Null
9634 }
9635 if resTmp == nil {
9636 if !graphql.HasFieldError(ctx, fc) {
9637 ec.Errorf(ctx, "must not be null")
9638 }
9639 return graphql.Null
9640 }
9641 res := resTmp.([]bug.TimelineItem)
9642 fc.Result = res
9643 return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx, field.Selections, res)
9644}
9645
9646func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9647 defer func() {
9648 if r := recover(); r != nil {
9649 ec.Error(ctx, ec.Recover(ctx, r))
9650 ret = graphql.Null
9651 }
9652 }()
9653 fc := &graphql.FieldContext{
9654 Object: "TimelineItemConnection",
9655 Field: field,
9656 Args: nil,
9657 IsMethod: false,
9658 IsResolver: false,
9659 }
9660
9661 ctx = graphql.WithFieldContext(ctx, fc)
9662 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9663 ctx = rctx // use context from middleware stack in children
9664 return obj.PageInfo, nil
9665 })
9666 if err != nil {
9667 ec.Error(ctx, err)
9668 return graphql.Null
9669 }
9670 if resTmp == nil {
9671 if !graphql.HasFieldError(ctx, fc) {
9672 ec.Errorf(ctx, "must not be null")
9673 }
9674 return graphql.Null
9675 }
9676 res := resTmp.(*models.PageInfo)
9677 fc.Result = res
9678 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
9679}
9680
9681func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9682 defer func() {
9683 if r := recover(); r != nil {
9684 ec.Error(ctx, ec.Recover(ctx, r))
9685 ret = graphql.Null
9686 }
9687 }()
9688 fc := &graphql.FieldContext{
9689 Object: "TimelineItemConnection",
9690 Field: field,
9691 Args: nil,
9692 IsMethod: false,
9693 IsResolver: false,
9694 }
9695
9696 ctx = graphql.WithFieldContext(ctx, fc)
9697 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9698 ctx = rctx // use context from middleware stack in children
9699 return obj.TotalCount, nil
9700 })
9701 if err != nil {
9702 ec.Error(ctx, err)
9703 return graphql.Null
9704 }
9705 if resTmp == nil {
9706 if !graphql.HasFieldError(ctx, fc) {
9707 ec.Errorf(ctx, "must not be null")
9708 }
9709 return graphql.Null
9710 }
9711 res := resTmp.(int)
9712 fc.Result = res
9713 return ec.marshalNInt2int(ctx, field.Selections, res)
9714}
9715
9716func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9717 defer func() {
9718 if r := recover(); r != nil {
9719 ec.Error(ctx, ec.Recover(ctx, r))
9720 ret = graphql.Null
9721 }
9722 }()
9723 fc := &graphql.FieldContext{
9724 Object: "TimelineItemEdge",
9725 Field: field,
9726 Args: nil,
9727 IsMethod: false,
9728 IsResolver: false,
9729 }
9730
9731 ctx = graphql.WithFieldContext(ctx, fc)
9732 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9733 ctx = rctx // use context from middleware stack in children
9734 return obj.Cursor, nil
9735 })
9736 if err != nil {
9737 ec.Error(ctx, err)
9738 return graphql.Null
9739 }
9740 if resTmp == nil {
9741 if !graphql.HasFieldError(ctx, fc) {
9742 ec.Errorf(ctx, "must not be null")
9743 }
9744 return graphql.Null
9745 }
9746 res := resTmp.(string)
9747 fc.Result = res
9748 return ec.marshalNString2string(ctx, field.Selections, res)
9749}
9750
9751func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9752 defer func() {
9753 if r := recover(); r != nil {
9754 ec.Error(ctx, ec.Recover(ctx, r))
9755 ret = graphql.Null
9756 }
9757 }()
9758 fc := &graphql.FieldContext{
9759 Object: "TimelineItemEdge",
9760 Field: field,
9761 Args: nil,
9762 IsMethod: false,
9763 IsResolver: false,
9764 }
9765
9766 ctx = graphql.WithFieldContext(ctx, fc)
9767 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9768 ctx = rctx // use context from middleware stack in children
9769 return obj.Node, nil
9770 })
9771 if err != nil {
9772 ec.Error(ctx, err)
9773 return graphql.Null
9774 }
9775 if resTmp == nil {
9776 if !graphql.HasFieldError(ctx, fc) {
9777 ec.Errorf(ctx, "must not be null")
9778 }
9779 return graphql.Null
9780 }
9781 res := resTmp.(bug.TimelineItem)
9782 fc.Result = res
9783 return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
9784}
9785
9786func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9787 defer func() {
9788 if r := recover(); r != nil {
9789 ec.Error(ctx, ec.Recover(ctx, r))
9790 ret = graphql.Null
9791 }
9792 }()
9793 fc := &graphql.FieldContext{
9794 Object: "__Directive",
9795 Field: field,
9796 Args: nil,
9797 IsMethod: false,
9798 IsResolver: false,
9799 }
9800
9801 ctx = graphql.WithFieldContext(ctx, fc)
9802 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9803 ctx = rctx // use context from middleware stack in children
9804 return obj.Name, nil
9805 })
9806 if err != nil {
9807 ec.Error(ctx, err)
9808 return graphql.Null
9809 }
9810 if resTmp == nil {
9811 if !graphql.HasFieldError(ctx, fc) {
9812 ec.Errorf(ctx, "must not be null")
9813 }
9814 return graphql.Null
9815 }
9816 res := resTmp.(string)
9817 fc.Result = res
9818 return ec.marshalNString2string(ctx, field.Selections, res)
9819}
9820
9821func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9822 defer func() {
9823 if r := recover(); r != nil {
9824 ec.Error(ctx, ec.Recover(ctx, r))
9825 ret = graphql.Null
9826 }
9827 }()
9828 fc := &graphql.FieldContext{
9829 Object: "__Directive",
9830 Field: field,
9831 Args: nil,
9832 IsMethod: false,
9833 IsResolver: false,
9834 }
9835
9836 ctx = graphql.WithFieldContext(ctx, fc)
9837 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9838 ctx = rctx // use context from middleware stack in children
9839 return obj.Description, nil
9840 })
9841 if err != nil {
9842 ec.Error(ctx, err)
9843 return graphql.Null
9844 }
9845 if resTmp == nil {
9846 return graphql.Null
9847 }
9848 res := resTmp.(string)
9849 fc.Result = res
9850 return ec.marshalOString2string(ctx, field.Selections, res)
9851}
9852
9853func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9854 defer func() {
9855 if r := recover(); r != nil {
9856 ec.Error(ctx, ec.Recover(ctx, r))
9857 ret = graphql.Null
9858 }
9859 }()
9860 fc := &graphql.FieldContext{
9861 Object: "__Directive",
9862 Field: field,
9863 Args: nil,
9864 IsMethod: false,
9865 IsResolver: false,
9866 }
9867
9868 ctx = graphql.WithFieldContext(ctx, fc)
9869 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9870 ctx = rctx // use context from middleware stack in children
9871 return obj.Locations, nil
9872 })
9873 if err != nil {
9874 ec.Error(ctx, err)
9875 return graphql.Null
9876 }
9877 if resTmp == nil {
9878 if !graphql.HasFieldError(ctx, fc) {
9879 ec.Errorf(ctx, "must not be null")
9880 }
9881 return graphql.Null
9882 }
9883 res := resTmp.([]string)
9884 fc.Result = res
9885 return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
9886}
9887
9888func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9889 defer func() {
9890 if r := recover(); r != nil {
9891 ec.Error(ctx, ec.Recover(ctx, r))
9892 ret = graphql.Null
9893 }
9894 }()
9895 fc := &graphql.FieldContext{
9896 Object: "__Directive",
9897 Field: field,
9898 Args: nil,
9899 IsMethod: false,
9900 IsResolver: false,
9901 }
9902
9903 ctx = graphql.WithFieldContext(ctx, fc)
9904 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9905 ctx = rctx // use context from middleware stack in children
9906 return obj.Args, nil
9907 })
9908 if err != nil {
9909 ec.Error(ctx, err)
9910 return graphql.Null
9911 }
9912 if resTmp == nil {
9913 if !graphql.HasFieldError(ctx, fc) {
9914 ec.Errorf(ctx, "must not be null")
9915 }
9916 return graphql.Null
9917 }
9918 res := resTmp.([]introspection.InputValue)
9919 fc.Result = res
9920 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
9921}
9922
9923func (ec *executionContext) ___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9924 defer func() {
9925 if r := recover(); r != nil {
9926 ec.Error(ctx, ec.Recover(ctx, r))
9927 ret = graphql.Null
9928 }
9929 }()
9930 fc := &graphql.FieldContext{
9931 Object: "__Directive",
9932 Field: field,
9933 Args: nil,
9934 IsMethod: false,
9935 IsResolver: false,
9936 }
9937
9938 ctx = graphql.WithFieldContext(ctx, fc)
9939 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9940 ctx = rctx // use context from middleware stack in children
9941 return obj.IsRepeatable, nil
9942 })
9943 if err != nil {
9944 ec.Error(ctx, err)
9945 return graphql.Null
9946 }
9947 if resTmp == nil {
9948 if !graphql.HasFieldError(ctx, fc) {
9949 ec.Errorf(ctx, "must not be null")
9950 }
9951 return graphql.Null
9952 }
9953 res := resTmp.(bool)
9954 fc.Result = res
9955 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9956}
9957
9958func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9959 defer func() {
9960 if r := recover(); r != nil {
9961 ec.Error(ctx, ec.Recover(ctx, r))
9962 ret = graphql.Null
9963 }
9964 }()
9965 fc := &graphql.FieldContext{
9966 Object: "__EnumValue",
9967 Field: field,
9968 Args: nil,
9969 IsMethod: false,
9970 IsResolver: false,
9971 }
9972
9973 ctx = graphql.WithFieldContext(ctx, fc)
9974 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9975 ctx = rctx // use context from middleware stack in children
9976 return obj.Name, nil
9977 })
9978 if err != nil {
9979 ec.Error(ctx, err)
9980 return graphql.Null
9981 }
9982 if resTmp == nil {
9983 if !graphql.HasFieldError(ctx, fc) {
9984 ec.Errorf(ctx, "must not be null")
9985 }
9986 return graphql.Null
9987 }
9988 res := resTmp.(string)
9989 fc.Result = res
9990 return ec.marshalNString2string(ctx, field.Selections, res)
9991}
9992
9993func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9994 defer func() {
9995 if r := recover(); r != nil {
9996 ec.Error(ctx, ec.Recover(ctx, r))
9997 ret = graphql.Null
9998 }
9999 }()
10000 fc := &graphql.FieldContext{
10001 Object: "__EnumValue",
10002 Field: field,
10003 Args: nil,
10004 IsMethod: false,
10005 IsResolver: false,
10006 }
10007
10008 ctx = graphql.WithFieldContext(ctx, fc)
10009 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10010 ctx = rctx // use context from middleware stack in children
10011 return obj.Description, nil
10012 })
10013 if err != nil {
10014 ec.Error(ctx, err)
10015 return graphql.Null
10016 }
10017 if resTmp == nil {
10018 return graphql.Null
10019 }
10020 res := resTmp.(string)
10021 fc.Result = res
10022 return ec.marshalOString2string(ctx, field.Selections, res)
10023}
10024
10025func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
10026 defer func() {
10027 if r := recover(); r != nil {
10028 ec.Error(ctx, ec.Recover(ctx, r))
10029 ret = graphql.Null
10030 }
10031 }()
10032 fc := &graphql.FieldContext{
10033 Object: "__EnumValue",
10034 Field: field,
10035 Args: nil,
10036 IsMethod: true,
10037 IsResolver: false,
10038 }
10039
10040 ctx = graphql.WithFieldContext(ctx, fc)
10041 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10042 ctx = rctx // use context from middleware stack in children
10043 return obj.IsDeprecated(), nil
10044 })
10045 if err != nil {
10046 ec.Error(ctx, err)
10047 return graphql.Null
10048 }
10049 if resTmp == nil {
10050 if !graphql.HasFieldError(ctx, fc) {
10051 ec.Errorf(ctx, "must not be null")
10052 }
10053 return graphql.Null
10054 }
10055 res := resTmp.(bool)
10056 fc.Result = res
10057 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
10058}
10059
10060func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
10061 defer func() {
10062 if r := recover(); r != nil {
10063 ec.Error(ctx, ec.Recover(ctx, r))
10064 ret = graphql.Null
10065 }
10066 }()
10067 fc := &graphql.FieldContext{
10068 Object: "__EnumValue",
10069 Field: field,
10070 Args: nil,
10071 IsMethod: true,
10072 IsResolver: false,
10073 }
10074
10075 ctx = graphql.WithFieldContext(ctx, fc)
10076 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10077 ctx = rctx // use context from middleware stack in children
10078 return obj.DeprecationReason(), nil
10079 })
10080 if err != nil {
10081 ec.Error(ctx, err)
10082 return graphql.Null
10083 }
10084 if resTmp == nil {
10085 return graphql.Null
10086 }
10087 res := resTmp.(*string)
10088 fc.Result = res
10089 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10090}
10091
10092func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
10093 defer func() {
10094 if r := recover(); r != nil {
10095 ec.Error(ctx, ec.Recover(ctx, r))
10096 ret = graphql.Null
10097 }
10098 }()
10099 fc := &graphql.FieldContext{
10100 Object: "__Field",
10101 Field: field,
10102 Args: nil,
10103 IsMethod: false,
10104 IsResolver: false,
10105 }
10106
10107 ctx = graphql.WithFieldContext(ctx, fc)
10108 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10109 ctx = rctx // use context from middleware stack in children
10110 return obj.Name, nil
10111 })
10112 if err != nil {
10113 ec.Error(ctx, err)
10114 return graphql.Null
10115 }
10116 if resTmp == nil {
10117 if !graphql.HasFieldError(ctx, fc) {
10118 ec.Errorf(ctx, "must not be null")
10119 }
10120 return graphql.Null
10121 }
10122 res := resTmp.(string)
10123 fc.Result = res
10124 return ec.marshalNString2string(ctx, field.Selections, res)
10125}
10126
10127func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
10128 defer func() {
10129 if r := recover(); r != nil {
10130 ec.Error(ctx, ec.Recover(ctx, r))
10131 ret = graphql.Null
10132 }
10133 }()
10134 fc := &graphql.FieldContext{
10135 Object: "__Field",
10136 Field: field,
10137 Args: nil,
10138 IsMethod: false,
10139 IsResolver: false,
10140 }
10141
10142 ctx = graphql.WithFieldContext(ctx, fc)
10143 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10144 ctx = rctx // use context from middleware stack in children
10145 return obj.Description, nil
10146 })
10147 if err != nil {
10148 ec.Error(ctx, err)
10149 return graphql.Null
10150 }
10151 if resTmp == nil {
10152 return graphql.Null
10153 }
10154 res := resTmp.(string)
10155 fc.Result = res
10156 return ec.marshalOString2string(ctx, field.Selections, res)
10157}
10158
10159func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
10160 defer func() {
10161 if r := recover(); r != nil {
10162 ec.Error(ctx, ec.Recover(ctx, r))
10163 ret = graphql.Null
10164 }
10165 }()
10166 fc := &graphql.FieldContext{
10167 Object: "__Field",
10168 Field: field,
10169 Args: nil,
10170 IsMethod: false,
10171 IsResolver: false,
10172 }
10173
10174 ctx = graphql.WithFieldContext(ctx, fc)
10175 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10176 ctx = rctx // use context from middleware stack in children
10177 return obj.Args, nil
10178 })
10179 if err != nil {
10180 ec.Error(ctx, err)
10181 return graphql.Null
10182 }
10183 if resTmp == nil {
10184 if !graphql.HasFieldError(ctx, fc) {
10185 ec.Errorf(ctx, "must not be null")
10186 }
10187 return graphql.Null
10188 }
10189 res := resTmp.([]introspection.InputValue)
10190 fc.Result = res
10191 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
10192}
10193
10194func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
10195 defer func() {
10196 if r := recover(); r != nil {
10197 ec.Error(ctx, ec.Recover(ctx, r))
10198 ret = graphql.Null
10199 }
10200 }()
10201 fc := &graphql.FieldContext{
10202 Object: "__Field",
10203 Field: field,
10204 Args: nil,
10205 IsMethod: false,
10206 IsResolver: false,
10207 }
10208
10209 ctx = graphql.WithFieldContext(ctx, fc)
10210 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10211 ctx = rctx // use context from middleware stack in children
10212 return obj.Type, nil
10213 })
10214 if err != nil {
10215 ec.Error(ctx, err)
10216 return graphql.Null
10217 }
10218 if resTmp == nil {
10219 if !graphql.HasFieldError(ctx, fc) {
10220 ec.Errorf(ctx, "must not be null")
10221 }
10222 return graphql.Null
10223 }
10224 res := resTmp.(*introspection.Type)
10225 fc.Result = res
10226 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10227}
10228
10229func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
10230 defer func() {
10231 if r := recover(); r != nil {
10232 ec.Error(ctx, ec.Recover(ctx, r))
10233 ret = graphql.Null
10234 }
10235 }()
10236 fc := &graphql.FieldContext{
10237 Object: "__Field",
10238 Field: field,
10239 Args: nil,
10240 IsMethod: true,
10241 IsResolver: false,
10242 }
10243
10244 ctx = graphql.WithFieldContext(ctx, fc)
10245 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10246 ctx = rctx // use context from middleware stack in children
10247 return obj.IsDeprecated(), nil
10248 })
10249 if err != nil {
10250 ec.Error(ctx, err)
10251 return graphql.Null
10252 }
10253 if resTmp == nil {
10254 if !graphql.HasFieldError(ctx, fc) {
10255 ec.Errorf(ctx, "must not be null")
10256 }
10257 return graphql.Null
10258 }
10259 res := resTmp.(bool)
10260 fc.Result = res
10261 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
10262}
10263
10264func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
10265 defer func() {
10266 if r := recover(); r != nil {
10267 ec.Error(ctx, ec.Recover(ctx, r))
10268 ret = graphql.Null
10269 }
10270 }()
10271 fc := &graphql.FieldContext{
10272 Object: "__Field",
10273 Field: field,
10274 Args: nil,
10275 IsMethod: true,
10276 IsResolver: false,
10277 }
10278
10279 ctx = graphql.WithFieldContext(ctx, fc)
10280 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10281 ctx = rctx // use context from middleware stack in children
10282 return obj.DeprecationReason(), nil
10283 })
10284 if err != nil {
10285 ec.Error(ctx, err)
10286 return graphql.Null
10287 }
10288 if resTmp == nil {
10289 return graphql.Null
10290 }
10291 res := resTmp.(*string)
10292 fc.Result = res
10293 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10294}
10295
10296func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
10297 defer func() {
10298 if r := recover(); r != nil {
10299 ec.Error(ctx, ec.Recover(ctx, r))
10300 ret = graphql.Null
10301 }
10302 }()
10303 fc := &graphql.FieldContext{
10304 Object: "__InputValue",
10305 Field: field,
10306 Args: nil,
10307 IsMethod: false,
10308 IsResolver: false,
10309 }
10310
10311 ctx = graphql.WithFieldContext(ctx, fc)
10312 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10313 ctx = rctx // use context from middleware stack in children
10314 return obj.Name, nil
10315 })
10316 if err != nil {
10317 ec.Error(ctx, err)
10318 return graphql.Null
10319 }
10320 if resTmp == nil {
10321 if !graphql.HasFieldError(ctx, fc) {
10322 ec.Errorf(ctx, "must not be null")
10323 }
10324 return graphql.Null
10325 }
10326 res := resTmp.(string)
10327 fc.Result = res
10328 return ec.marshalNString2string(ctx, field.Selections, res)
10329}
10330
10331func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
10332 defer func() {
10333 if r := recover(); r != nil {
10334 ec.Error(ctx, ec.Recover(ctx, r))
10335 ret = graphql.Null
10336 }
10337 }()
10338 fc := &graphql.FieldContext{
10339 Object: "__InputValue",
10340 Field: field,
10341 Args: nil,
10342 IsMethod: false,
10343 IsResolver: false,
10344 }
10345
10346 ctx = graphql.WithFieldContext(ctx, fc)
10347 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10348 ctx = rctx // use context from middleware stack in children
10349 return obj.Description, nil
10350 })
10351 if err != nil {
10352 ec.Error(ctx, err)
10353 return graphql.Null
10354 }
10355 if resTmp == nil {
10356 return graphql.Null
10357 }
10358 res := resTmp.(string)
10359 fc.Result = res
10360 return ec.marshalOString2string(ctx, field.Selections, res)
10361}
10362
10363func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
10364 defer func() {
10365 if r := recover(); r != nil {
10366 ec.Error(ctx, ec.Recover(ctx, r))
10367 ret = graphql.Null
10368 }
10369 }()
10370 fc := &graphql.FieldContext{
10371 Object: "__InputValue",
10372 Field: field,
10373 Args: nil,
10374 IsMethod: false,
10375 IsResolver: false,
10376 }
10377
10378 ctx = graphql.WithFieldContext(ctx, fc)
10379 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10380 ctx = rctx // use context from middleware stack in children
10381 return obj.Type, nil
10382 })
10383 if err != nil {
10384 ec.Error(ctx, err)
10385 return graphql.Null
10386 }
10387 if resTmp == nil {
10388 if !graphql.HasFieldError(ctx, fc) {
10389 ec.Errorf(ctx, "must not be null")
10390 }
10391 return graphql.Null
10392 }
10393 res := resTmp.(*introspection.Type)
10394 fc.Result = res
10395 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10396}
10397
10398func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
10399 defer func() {
10400 if r := recover(); r != nil {
10401 ec.Error(ctx, ec.Recover(ctx, r))
10402 ret = graphql.Null
10403 }
10404 }()
10405 fc := &graphql.FieldContext{
10406 Object: "__InputValue",
10407 Field: field,
10408 Args: nil,
10409 IsMethod: false,
10410 IsResolver: false,
10411 }
10412
10413 ctx = graphql.WithFieldContext(ctx, fc)
10414 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10415 ctx = rctx // use context from middleware stack in children
10416 return obj.DefaultValue, nil
10417 })
10418 if err != nil {
10419 ec.Error(ctx, err)
10420 return graphql.Null
10421 }
10422 if resTmp == nil {
10423 return graphql.Null
10424 }
10425 res := resTmp.(*string)
10426 fc.Result = res
10427 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10428}
10429
10430func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10431 defer func() {
10432 if r := recover(); r != nil {
10433 ec.Error(ctx, ec.Recover(ctx, r))
10434 ret = graphql.Null
10435 }
10436 }()
10437 fc := &graphql.FieldContext{
10438 Object: "__Schema",
10439 Field: field,
10440 Args: nil,
10441 IsMethod: true,
10442 IsResolver: false,
10443 }
10444
10445 ctx = graphql.WithFieldContext(ctx, fc)
10446 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10447 ctx = rctx // use context from middleware stack in children
10448 return obj.Types(), nil
10449 })
10450 if err != nil {
10451 ec.Error(ctx, err)
10452 return graphql.Null
10453 }
10454 if resTmp == nil {
10455 if !graphql.HasFieldError(ctx, fc) {
10456 ec.Errorf(ctx, "must not be null")
10457 }
10458 return graphql.Null
10459 }
10460 res := resTmp.([]introspection.Type)
10461 fc.Result = res
10462 return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10463}
10464
10465func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10466 defer func() {
10467 if r := recover(); r != nil {
10468 ec.Error(ctx, ec.Recover(ctx, r))
10469 ret = graphql.Null
10470 }
10471 }()
10472 fc := &graphql.FieldContext{
10473 Object: "__Schema",
10474 Field: field,
10475 Args: nil,
10476 IsMethod: true,
10477 IsResolver: false,
10478 }
10479
10480 ctx = graphql.WithFieldContext(ctx, fc)
10481 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10482 ctx = rctx // use context from middleware stack in children
10483 return obj.QueryType(), nil
10484 })
10485 if err != nil {
10486 ec.Error(ctx, err)
10487 return graphql.Null
10488 }
10489 if resTmp == nil {
10490 if !graphql.HasFieldError(ctx, fc) {
10491 ec.Errorf(ctx, "must not be null")
10492 }
10493 return graphql.Null
10494 }
10495 res := resTmp.(*introspection.Type)
10496 fc.Result = res
10497 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10498}
10499
10500func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10501 defer func() {
10502 if r := recover(); r != nil {
10503 ec.Error(ctx, ec.Recover(ctx, r))
10504 ret = graphql.Null
10505 }
10506 }()
10507 fc := &graphql.FieldContext{
10508 Object: "__Schema",
10509 Field: field,
10510 Args: nil,
10511 IsMethod: true,
10512 IsResolver: false,
10513 }
10514
10515 ctx = graphql.WithFieldContext(ctx, fc)
10516 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10517 ctx = rctx // use context from middleware stack in children
10518 return obj.MutationType(), nil
10519 })
10520 if err != nil {
10521 ec.Error(ctx, err)
10522 return graphql.Null
10523 }
10524 if resTmp == nil {
10525 return graphql.Null
10526 }
10527 res := resTmp.(*introspection.Type)
10528 fc.Result = res
10529 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10530}
10531
10532func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10533 defer func() {
10534 if r := recover(); r != nil {
10535 ec.Error(ctx, ec.Recover(ctx, r))
10536 ret = graphql.Null
10537 }
10538 }()
10539 fc := &graphql.FieldContext{
10540 Object: "__Schema",
10541 Field: field,
10542 Args: nil,
10543 IsMethod: true,
10544 IsResolver: false,
10545 }
10546
10547 ctx = graphql.WithFieldContext(ctx, fc)
10548 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10549 ctx = rctx // use context from middleware stack in children
10550 return obj.SubscriptionType(), nil
10551 })
10552 if err != nil {
10553 ec.Error(ctx, err)
10554 return graphql.Null
10555 }
10556 if resTmp == nil {
10557 return graphql.Null
10558 }
10559 res := resTmp.(*introspection.Type)
10560 fc.Result = res
10561 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10562}
10563
10564func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10565 defer func() {
10566 if r := recover(); r != nil {
10567 ec.Error(ctx, ec.Recover(ctx, r))
10568 ret = graphql.Null
10569 }
10570 }()
10571 fc := &graphql.FieldContext{
10572 Object: "__Schema",
10573 Field: field,
10574 Args: nil,
10575 IsMethod: true,
10576 IsResolver: false,
10577 }
10578
10579 ctx = graphql.WithFieldContext(ctx, fc)
10580 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10581 ctx = rctx // use context from middleware stack in children
10582 return obj.Directives(), nil
10583 })
10584 if err != nil {
10585 ec.Error(ctx, err)
10586 return graphql.Null
10587 }
10588 if resTmp == nil {
10589 if !graphql.HasFieldError(ctx, fc) {
10590 ec.Errorf(ctx, "must not be null")
10591 }
10592 return graphql.Null
10593 }
10594 res := resTmp.([]introspection.Directive)
10595 fc.Result = res
10596 return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
10597}
10598
10599func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10600 defer func() {
10601 if r := recover(); r != nil {
10602 ec.Error(ctx, ec.Recover(ctx, r))
10603 ret = graphql.Null
10604 }
10605 }()
10606 fc := &graphql.FieldContext{
10607 Object: "__Type",
10608 Field: field,
10609 Args: nil,
10610 IsMethod: true,
10611 IsResolver: false,
10612 }
10613
10614 ctx = graphql.WithFieldContext(ctx, fc)
10615 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10616 ctx = rctx // use context from middleware stack in children
10617 return obj.Kind(), nil
10618 })
10619 if err != nil {
10620 ec.Error(ctx, err)
10621 return graphql.Null
10622 }
10623 if resTmp == nil {
10624 if !graphql.HasFieldError(ctx, fc) {
10625 ec.Errorf(ctx, "must not be null")
10626 }
10627 return graphql.Null
10628 }
10629 res := resTmp.(string)
10630 fc.Result = res
10631 return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
10632}
10633
10634func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10635 defer func() {
10636 if r := recover(); r != nil {
10637 ec.Error(ctx, ec.Recover(ctx, r))
10638 ret = graphql.Null
10639 }
10640 }()
10641 fc := &graphql.FieldContext{
10642 Object: "__Type",
10643 Field: field,
10644 Args: nil,
10645 IsMethod: true,
10646 IsResolver: false,
10647 }
10648
10649 ctx = graphql.WithFieldContext(ctx, fc)
10650 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10651 ctx = rctx // use context from middleware stack in children
10652 return obj.Name(), nil
10653 })
10654 if err != nil {
10655 ec.Error(ctx, err)
10656 return graphql.Null
10657 }
10658 if resTmp == nil {
10659 return graphql.Null
10660 }
10661 res := resTmp.(*string)
10662 fc.Result = res
10663 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10664}
10665
10666func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10667 defer func() {
10668 if r := recover(); r != nil {
10669 ec.Error(ctx, ec.Recover(ctx, r))
10670 ret = graphql.Null
10671 }
10672 }()
10673 fc := &graphql.FieldContext{
10674 Object: "__Type",
10675 Field: field,
10676 Args: nil,
10677 IsMethod: true,
10678 IsResolver: false,
10679 }
10680
10681 ctx = graphql.WithFieldContext(ctx, fc)
10682 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10683 ctx = rctx // use context from middleware stack in children
10684 return obj.Description(), nil
10685 })
10686 if err != nil {
10687 ec.Error(ctx, err)
10688 return graphql.Null
10689 }
10690 if resTmp == nil {
10691 return graphql.Null
10692 }
10693 res := resTmp.(string)
10694 fc.Result = res
10695 return ec.marshalOString2string(ctx, field.Selections, res)
10696}
10697
10698func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10699 defer func() {
10700 if r := recover(); r != nil {
10701 ec.Error(ctx, ec.Recover(ctx, r))
10702 ret = graphql.Null
10703 }
10704 }()
10705 fc := &graphql.FieldContext{
10706 Object: "__Type",
10707 Field: field,
10708 Args: nil,
10709 IsMethod: true,
10710 IsResolver: false,
10711 }
10712
10713 ctx = graphql.WithFieldContext(ctx, fc)
10714 rawArgs := field.ArgumentMap(ec.Variables)
10715 args, err := ec.field___Type_fields_args(ctx, rawArgs)
10716 if err != nil {
10717 ec.Error(ctx, err)
10718 return graphql.Null
10719 }
10720 fc.Args = args
10721 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10722 ctx = rctx // use context from middleware stack in children
10723 return obj.Fields(args["includeDeprecated"].(bool)), nil
10724 })
10725 if err != nil {
10726 ec.Error(ctx, err)
10727 return graphql.Null
10728 }
10729 if resTmp == nil {
10730 return graphql.Null
10731 }
10732 res := resTmp.([]introspection.Field)
10733 fc.Result = res
10734 return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
10735}
10736
10737func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10738 defer func() {
10739 if r := recover(); r != nil {
10740 ec.Error(ctx, ec.Recover(ctx, r))
10741 ret = graphql.Null
10742 }
10743 }()
10744 fc := &graphql.FieldContext{
10745 Object: "__Type",
10746 Field: field,
10747 Args: nil,
10748 IsMethod: true,
10749 IsResolver: false,
10750 }
10751
10752 ctx = graphql.WithFieldContext(ctx, fc)
10753 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10754 ctx = rctx // use context from middleware stack in children
10755 return obj.Interfaces(), nil
10756 })
10757 if err != nil {
10758 ec.Error(ctx, err)
10759 return graphql.Null
10760 }
10761 if resTmp == nil {
10762 return graphql.Null
10763 }
10764 res := resTmp.([]introspection.Type)
10765 fc.Result = res
10766 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10767}
10768
10769func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10770 defer func() {
10771 if r := recover(); r != nil {
10772 ec.Error(ctx, ec.Recover(ctx, r))
10773 ret = graphql.Null
10774 }
10775 }()
10776 fc := &graphql.FieldContext{
10777 Object: "__Type",
10778 Field: field,
10779 Args: nil,
10780 IsMethod: true,
10781 IsResolver: false,
10782 }
10783
10784 ctx = graphql.WithFieldContext(ctx, fc)
10785 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10786 ctx = rctx // use context from middleware stack in children
10787 return obj.PossibleTypes(), nil
10788 })
10789 if err != nil {
10790 ec.Error(ctx, err)
10791 return graphql.Null
10792 }
10793 if resTmp == nil {
10794 return graphql.Null
10795 }
10796 res := resTmp.([]introspection.Type)
10797 fc.Result = res
10798 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10799}
10800
10801func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10802 defer func() {
10803 if r := recover(); r != nil {
10804 ec.Error(ctx, ec.Recover(ctx, r))
10805 ret = graphql.Null
10806 }
10807 }()
10808 fc := &graphql.FieldContext{
10809 Object: "__Type",
10810 Field: field,
10811 Args: nil,
10812 IsMethod: true,
10813 IsResolver: false,
10814 }
10815
10816 ctx = graphql.WithFieldContext(ctx, fc)
10817 rawArgs := field.ArgumentMap(ec.Variables)
10818 args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
10819 if err != nil {
10820 ec.Error(ctx, err)
10821 return graphql.Null
10822 }
10823 fc.Args = args
10824 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10825 ctx = rctx // use context from middleware stack in children
10826 return obj.EnumValues(args["includeDeprecated"].(bool)), nil
10827 })
10828 if err != nil {
10829 ec.Error(ctx, err)
10830 return graphql.Null
10831 }
10832 if resTmp == nil {
10833 return graphql.Null
10834 }
10835 res := resTmp.([]introspection.EnumValue)
10836 fc.Result = res
10837 return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
10838}
10839
10840func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10841 defer func() {
10842 if r := recover(); r != nil {
10843 ec.Error(ctx, ec.Recover(ctx, r))
10844 ret = graphql.Null
10845 }
10846 }()
10847 fc := &graphql.FieldContext{
10848 Object: "__Type",
10849 Field: field,
10850 Args: nil,
10851 IsMethod: true,
10852 IsResolver: false,
10853 }
10854
10855 ctx = graphql.WithFieldContext(ctx, fc)
10856 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10857 ctx = rctx // use context from middleware stack in children
10858 return obj.InputFields(), nil
10859 })
10860 if err != nil {
10861 ec.Error(ctx, err)
10862 return graphql.Null
10863 }
10864 if resTmp == nil {
10865 return graphql.Null
10866 }
10867 res := resTmp.([]introspection.InputValue)
10868 fc.Result = res
10869 return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
10870}
10871
10872func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10873 defer func() {
10874 if r := recover(); r != nil {
10875 ec.Error(ctx, ec.Recover(ctx, r))
10876 ret = graphql.Null
10877 }
10878 }()
10879 fc := &graphql.FieldContext{
10880 Object: "__Type",
10881 Field: field,
10882 Args: nil,
10883 IsMethod: true,
10884 IsResolver: false,
10885 }
10886
10887 ctx = graphql.WithFieldContext(ctx, fc)
10888 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10889 ctx = rctx // use context from middleware stack in children
10890 return obj.OfType(), nil
10891 })
10892 if err != nil {
10893 ec.Error(ctx, err)
10894 return graphql.Null
10895 }
10896 if resTmp == nil {
10897 return graphql.Null
10898 }
10899 res := resTmp.(*introspection.Type)
10900 fc.Result = res
10901 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10902}
10903
10904// endregion **************************** field.gotpl *****************************
10905
10906// region **************************** input.gotpl *****************************
10907
10908func (ec *executionContext) unmarshalInputAddCommentAndCloseBugInput(ctx context.Context, obj interface{}) (models.AddCommentAndCloseBugInput, error) {
10909 var it models.AddCommentAndCloseBugInput
10910 asMap := map[string]interface{}{}
10911 for k, v := range obj.(map[string]interface{}) {
10912 asMap[k] = v
10913 }
10914
10915 for k, v := range asMap {
10916 switch k {
10917 case "clientMutationId":
10918 var err error
10919
10920 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
10921 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10922 if err != nil {
10923 return it, err
10924 }
10925 case "repoRef":
10926 var err error
10927
10928 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
10929 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10930 if err != nil {
10931 return it, err
10932 }
10933 case "prefix":
10934 var err error
10935
10936 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
10937 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10938 if err != nil {
10939 return it, err
10940 }
10941 case "message":
10942 var err error
10943
10944 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
10945 it.Message, err = ec.unmarshalNString2string(ctx, v)
10946 if err != nil {
10947 return it, err
10948 }
10949 case "files":
10950 var err error
10951
10952 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
10953 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
10954 if err != nil {
10955 return it, err
10956 }
10957 }
10958 }
10959
10960 return it, nil
10961}
10962
10963func (ec *executionContext) unmarshalInputAddCommentAndReopenBugInput(ctx context.Context, obj interface{}) (models.AddCommentAndReopenBugInput, error) {
10964 var it models.AddCommentAndReopenBugInput
10965 asMap := map[string]interface{}{}
10966 for k, v := range obj.(map[string]interface{}) {
10967 asMap[k] = v
10968 }
10969
10970 for k, v := range asMap {
10971 switch k {
10972 case "clientMutationId":
10973 var err error
10974
10975 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
10976 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10977 if err != nil {
10978 return it, err
10979 }
10980 case "repoRef":
10981 var err error
10982
10983 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
10984 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10985 if err != nil {
10986 return it, err
10987 }
10988 case "prefix":
10989 var err error
10990
10991 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
10992 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10993 if err != nil {
10994 return it, err
10995 }
10996 case "message":
10997 var err error
10998
10999 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
11000 it.Message, err = ec.unmarshalNString2string(ctx, v)
11001 if err != nil {
11002 return it, err
11003 }
11004 case "files":
11005 var err error
11006
11007 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
11008 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
11009 if err != nil {
11010 return it, err
11011 }
11012 }
11013 }
11014
11015 return it, nil
11016}
11017
11018func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
11019 var it models.AddCommentInput
11020 asMap := map[string]interface{}{}
11021 for k, v := range obj.(map[string]interface{}) {
11022 asMap[k] = v
11023 }
11024
11025 for k, v := range asMap {
11026 switch k {
11027 case "clientMutationId":
11028 var err error
11029
11030 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
11031 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
11032 if err != nil {
11033 return it, err
11034 }
11035 case "repoRef":
11036 var err error
11037
11038 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
11039 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
11040 if err != nil {
11041 return it, err
11042 }
11043 case "prefix":
11044 var err error
11045
11046 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
11047 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
11048 if err != nil {
11049 return it, err
11050 }
11051 case "message":
11052 var err error
11053
11054 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
11055 it.Message, err = ec.unmarshalNString2string(ctx, v)
11056 if err != nil {
11057 return it, err
11058 }
11059 case "files":
11060 var err error
11061
11062 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
11063 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
11064 if err != nil {
11065 return it, err
11066 }
11067 }
11068 }
11069
11070 return it, nil
11071}
11072
11073func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
11074 var it models.ChangeLabelInput
11075 asMap := map[string]interface{}{}
11076 for k, v := range obj.(map[string]interface{}) {
11077 asMap[k] = v
11078 }
11079
11080 for k, v := range asMap {
11081 switch k {
11082 case "clientMutationId":
11083 var err error
11084
11085 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
11086 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
11087 if err != nil {
11088 return it, err
11089 }
11090 case "repoRef":
11091 var err error
11092
11093 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
11094 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
11095 if err != nil {
11096 return it, err
11097 }
11098 case "prefix":
11099 var err error
11100
11101 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
11102 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
11103 if err != nil {
11104 return it, err
11105 }
11106 case "added":
11107 var err error
11108
11109 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("added"))
11110 it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
11111 if err != nil {
11112 return it, err
11113 }
11114 case "Removed":
11115 var err error
11116
11117 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Removed"))
11118 it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
11119 if err != nil {
11120 return it, err
11121 }
11122 }
11123 }
11124
11125 return it, nil
11126}
11127
11128func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
11129 var it models.CloseBugInput
11130 asMap := map[string]interface{}{}
11131 for k, v := range obj.(map[string]interface{}) {
11132 asMap[k] = v
11133 }
11134
11135 for k, v := range asMap {
11136 switch k {
11137 case "clientMutationId":
11138 var err error
11139
11140 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
11141 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
11142 if err != nil {
11143 return it, err
11144 }
11145 case "repoRef":
11146 var err error
11147
11148 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
11149 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
11150 if err != nil {
11151 return it, err
11152 }
11153 case "prefix":
11154 var err error
11155
11156 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
11157 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
11158 if err != nil {
11159 return it, err
11160 }
11161 }
11162 }
11163
11164 return it, nil
11165}
11166
11167func (ec *executionContext) unmarshalInputEditCommentInput(ctx context.Context, obj interface{}) (models.EditCommentInput, error) {
11168 var it models.EditCommentInput
11169 asMap := map[string]interface{}{}
11170 for k, v := range obj.(map[string]interface{}) {
11171 asMap[k] = v
11172 }
11173
11174 for k, v := range asMap {
11175 switch k {
11176 case "clientMutationId":
11177 var err error
11178
11179 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
11180 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
11181 if err != nil {
11182 return it, err
11183 }
11184 case "repoRef":
11185 var err error
11186
11187 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
11188 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
11189 if err != nil {
11190 return it, err
11191 }
11192 case "prefix":
11193 var err error
11194
11195 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
11196 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
11197 if err != nil {
11198 return it, err
11199 }
11200 case "target":
11201 var err error
11202
11203 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("target"))
11204 it.Target, err = ec.unmarshalNString2string(ctx, v)
11205 if err != nil {
11206 return it, err
11207 }
11208 case "message":
11209 var err error
11210
11211 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
11212 it.Message, err = ec.unmarshalNString2string(ctx, v)
11213 if err != nil {
11214 return it, err
11215 }
11216 case "files":
11217 var err error
11218
11219 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
11220 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
11221 if err != nil {
11222 return it, err
11223 }
11224 }
11225 }
11226
11227 return it, nil
11228}
11229
11230func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
11231 var it models.NewBugInput
11232 asMap := map[string]interface{}{}
11233 for k, v := range obj.(map[string]interface{}) {
11234 asMap[k] = v
11235 }
11236
11237 for k, v := range asMap {
11238 switch k {
11239 case "clientMutationId":
11240 var err error
11241
11242 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
11243 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
11244 if err != nil {
11245 return it, err
11246 }
11247 case "repoRef":
11248 var err error
11249
11250 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
11251 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
11252 if err != nil {
11253 return it, err
11254 }
11255 case "title":
11256 var err error
11257
11258 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
11259 it.Title, err = ec.unmarshalNString2string(ctx, v)
11260 if err != nil {
11261 return it, err
11262 }
11263 case "message":
11264 var err error
11265
11266 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
11267 it.Message, err = ec.unmarshalNString2string(ctx, v)
11268 if err != nil {
11269 return it, err
11270 }
11271 case "files":
11272 var err error
11273
11274 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
11275 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
11276 if err != nil {
11277 return it, err
11278 }
11279 }
11280 }
11281
11282 return it, nil
11283}
11284
11285func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
11286 var it models.OpenBugInput
11287 asMap := map[string]interface{}{}
11288 for k, v := range obj.(map[string]interface{}) {
11289 asMap[k] = v
11290 }
11291
11292 for k, v := range asMap {
11293 switch k {
11294 case "clientMutationId":
11295 var err error
11296
11297 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
11298 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
11299 if err != nil {
11300 return it, err
11301 }
11302 case "repoRef":
11303 var err error
11304
11305 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
11306 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
11307 if err != nil {
11308 return it, err
11309 }
11310 case "prefix":
11311 var err error
11312
11313 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
11314 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
11315 if err != nil {
11316 return it, err
11317 }
11318 }
11319 }
11320
11321 return it, nil
11322}
11323
11324func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
11325 var it models.SetTitleInput
11326 asMap := map[string]interface{}{}
11327 for k, v := range obj.(map[string]interface{}) {
11328 asMap[k] = v
11329 }
11330
11331 for k, v := range asMap {
11332 switch k {
11333 case "clientMutationId":
11334 var err error
11335
11336 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
11337 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
11338 if err != nil {
11339 return it, err
11340 }
11341 case "repoRef":
11342 var err error
11343
11344 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
11345 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
11346 if err != nil {
11347 return it, err
11348 }
11349 case "prefix":
11350 var err error
11351
11352 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
11353 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
11354 if err != nil {
11355 return it, err
11356 }
11357 case "title":
11358 var err error
11359
11360 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
11361 it.Title, err = ec.unmarshalNString2string(ctx, v)
11362 if err != nil {
11363 return it, err
11364 }
11365 }
11366 }
11367
11368 return it, nil
11369}
11370
11371// endregion **************************** input.gotpl *****************************
11372
11373// region ************************** interface.gotpl ***************************
11374
11375func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj models.Authored) graphql.Marshaler {
11376 switch obj := (obj).(type) {
11377 case nil:
11378 return graphql.Null
11379 case bug.Comment:
11380 return ec._Comment(ctx, sel, &obj)
11381 case *bug.Comment:
11382 if obj == nil {
11383 return graphql.Null
11384 }
11385 return ec._Comment(ctx, sel, obj)
11386 case models.BugWrapper:
11387 if obj == nil {
11388 return graphql.Null
11389 }
11390 return ec._Bug(ctx, sel, obj)
11391 case *bug.CreateOperation:
11392 if obj == nil {
11393 return graphql.Null
11394 }
11395 return ec._CreateOperation(ctx, sel, obj)
11396 case *bug.SetTitleOperation:
11397 if obj == nil {
11398 return graphql.Null
11399 }
11400 return ec._SetTitleOperation(ctx, sel, obj)
11401 case *bug.AddCommentOperation:
11402 if obj == nil {
11403 return graphql.Null
11404 }
11405 return ec._AddCommentOperation(ctx, sel, obj)
11406 case *bug.EditCommentOperation:
11407 if obj == nil {
11408 return graphql.Null
11409 }
11410 return ec._EditCommentOperation(ctx, sel, obj)
11411 case *bug.SetStatusOperation:
11412 if obj == nil {
11413 return graphql.Null
11414 }
11415 return ec._SetStatusOperation(ctx, sel, obj)
11416 case *bug.LabelChangeOperation:
11417 if obj == nil {
11418 return graphql.Null
11419 }
11420 return ec._LabelChangeOperation(ctx, sel, obj)
11421 case *bug.CreateTimelineItem:
11422 if obj == nil {
11423 return graphql.Null
11424 }
11425 return ec._CreateTimelineItem(ctx, sel, obj)
11426 case *bug.AddCommentTimelineItem:
11427 if obj == nil {
11428 return graphql.Null
11429 }
11430 return ec._AddCommentTimelineItem(ctx, sel, obj)
11431 case *bug.LabelChangeTimelineItem:
11432 if obj == nil {
11433 return graphql.Null
11434 }
11435 return ec._LabelChangeTimelineItem(ctx, sel, obj)
11436 case *bug.SetStatusTimelineItem:
11437 if obj == nil {
11438 return graphql.Null
11439 }
11440 return ec._SetStatusTimelineItem(ctx, sel, obj)
11441 case *bug.SetTitleTimelineItem:
11442 if obj == nil {
11443 return graphql.Null
11444 }
11445 return ec._SetTitleTimelineItem(ctx, sel, obj)
11446 default:
11447 panic(fmt.Errorf("unexpected type %T", obj))
11448 }
11449}
11450
11451func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj bug.Operation) graphql.Marshaler {
11452 switch obj := (obj).(type) {
11453 case nil:
11454 return graphql.Null
11455 case *bug.CreateOperation:
11456 if obj == nil {
11457 return graphql.Null
11458 }
11459 return ec._CreateOperation(ctx, sel, obj)
11460 case *bug.SetTitleOperation:
11461 if obj == nil {
11462 return graphql.Null
11463 }
11464 return ec._SetTitleOperation(ctx, sel, obj)
11465 case *bug.AddCommentOperation:
11466 if obj == nil {
11467 return graphql.Null
11468 }
11469 return ec._AddCommentOperation(ctx, sel, obj)
11470 case *bug.EditCommentOperation:
11471 if obj == nil {
11472 return graphql.Null
11473 }
11474 return ec._EditCommentOperation(ctx, sel, obj)
11475 case *bug.SetStatusOperation:
11476 if obj == nil {
11477 return graphql.Null
11478 }
11479 return ec._SetStatusOperation(ctx, sel, obj)
11480 case *bug.LabelChangeOperation:
11481 if obj == nil {
11482 return graphql.Null
11483 }
11484 return ec._LabelChangeOperation(ctx, sel, obj)
11485 default:
11486 panic(fmt.Errorf("unexpected type %T", obj))
11487 }
11488}
11489
11490func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
11491 switch obj := (obj).(type) {
11492 case nil:
11493 return graphql.Null
11494 case *bug.CreateTimelineItem:
11495 if obj == nil {
11496 return graphql.Null
11497 }
11498 return ec._CreateTimelineItem(ctx, sel, obj)
11499 case *bug.AddCommentTimelineItem:
11500 if obj == nil {
11501 return graphql.Null
11502 }
11503 return ec._AddCommentTimelineItem(ctx, sel, obj)
11504 case bug.LabelChangeTimelineItem:
11505 return ec._LabelChangeTimelineItem(ctx, sel, &obj)
11506 case *bug.LabelChangeTimelineItem:
11507 if obj == nil {
11508 return graphql.Null
11509 }
11510 return ec._LabelChangeTimelineItem(ctx, sel, obj)
11511 case bug.SetStatusTimelineItem:
11512 return ec._SetStatusTimelineItem(ctx, sel, &obj)
11513 case *bug.SetStatusTimelineItem:
11514 if obj == nil {
11515 return graphql.Null
11516 }
11517 return ec._SetStatusTimelineItem(ctx, sel, obj)
11518 case bug.SetTitleTimelineItem:
11519 return ec._SetTitleTimelineItem(ctx, sel, &obj)
11520 case *bug.SetTitleTimelineItem:
11521 if obj == nil {
11522 return graphql.Null
11523 }
11524 return ec._SetTitleTimelineItem(ctx, sel, obj)
11525 default:
11526 panic(fmt.Errorf("unexpected type %T", obj))
11527 }
11528}
11529
11530// endregion ************************** interface.gotpl ***************************
11531
11532// region **************************** object.gotpl ****************************
11533
11534var addCommentAndCloseBugPayloadImplementors = []string{"AddCommentAndCloseBugPayload"}
11535
11536func (ec *executionContext) _AddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentAndCloseBugPayload) graphql.Marshaler {
11537 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentAndCloseBugPayloadImplementors)
11538 out := graphql.NewFieldSet(fields)
11539 var invalids uint32
11540 for i, field := range fields {
11541 switch field.Name {
11542 case "__typename":
11543 out.Values[i] = graphql.MarshalString("AddCommentAndCloseBugPayload")
11544 case "clientMutationId":
11545 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11546 return ec._AddCommentAndCloseBugPayload_clientMutationId(ctx, field, obj)
11547 }
11548
11549 out.Values[i] = innerFunc(ctx)
11550
11551 case "bug":
11552 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11553 return ec._AddCommentAndCloseBugPayload_bug(ctx, field, obj)
11554 }
11555
11556 out.Values[i] = innerFunc(ctx)
11557
11558 if out.Values[i] == graphql.Null {
11559 invalids++
11560 }
11561 case "commentOperation":
11562 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11563 return ec._AddCommentAndCloseBugPayload_commentOperation(ctx, field, obj)
11564 }
11565
11566 out.Values[i] = innerFunc(ctx)
11567
11568 if out.Values[i] == graphql.Null {
11569 invalids++
11570 }
11571 case "statusOperation":
11572 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11573 return ec._AddCommentAndCloseBugPayload_statusOperation(ctx, field, obj)
11574 }
11575
11576 out.Values[i] = innerFunc(ctx)
11577
11578 if out.Values[i] == graphql.Null {
11579 invalids++
11580 }
11581 default:
11582 panic("unknown field " + strconv.Quote(field.Name))
11583 }
11584 }
11585 out.Dispatch()
11586 if invalids > 0 {
11587 return graphql.Null
11588 }
11589 return out
11590}
11591
11592var addCommentAndReopenBugPayloadImplementors = []string{"AddCommentAndReopenBugPayload"}
11593
11594func (ec *executionContext) _AddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentAndReopenBugPayload) graphql.Marshaler {
11595 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentAndReopenBugPayloadImplementors)
11596 out := graphql.NewFieldSet(fields)
11597 var invalids uint32
11598 for i, field := range fields {
11599 switch field.Name {
11600 case "__typename":
11601 out.Values[i] = graphql.MarshalString("AddCommentAndReopenBugPayload")
11602 case "clientMutationId":
11603 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11604 return ec._AddCommentAndReopenBugPayload_clientMutationId(ctx, field, obj)
11605 }
11606
11607 out.Values[i] = innerFunc(ctx)
11608
11609 case "bug":
11610 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11611 return ec._AddCommentAndReopenBugPayload_bug(ctx, field, obj)
11612 }
11613
11614 out.Values[i] = innerFunc(ctx)
11615
11616 if out.Values[i] == graphql.Null {
11617 invalids++
11618 }
11619 case "commentOperation":
11620 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11621 return ec._AddCommentAndReopenBugPayload_commentOperation(ctx, field, obj)
11622 }
11623
11624 out.Values[i] = innerFunc(ctx)
11625
11626 if out.Values[i] == graphql.Null {
11627 invalids++
11628 }
11629 case "statusOperation":
11630 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11631 return ec._AddCommentAndReopenBugPayload_statusOperation(ctx, field, obj)
11632 }
11633
11634 out.Values[i] = innerFunc(ctx)
11635
11636 if out.Values[i] == graphql.Null {
11637 invalids++
11638 }
11639 default:
11640 panic("unknown field " + strconv.Quote(field.Name))
11641 }
11642 }
11643 out.Dispatch()
11644 if invalids > 0 {
11645 return graphql.Null
11646 }
11647 return out
11648}
11649
11650var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
11651
11652func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
11653 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
11654 out := graphql.NewFieldSet(fields)
11655 var invalids uint32
11656 for i, field := range fields {
11657 switch field.Name {
11658 case "__typename":
11659 out.Values[i] = graphql.MarshalString("AddCommentOperation")
11660 case "id":
11661 field := field
11662
11663 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11664 defer func() {
11665 if r := recover(); r != nil {
11666 ec.Error(ctx, ec.Recover(ctx, r))
11667 }
11668 }()
11669 res = ec._AddCommentOperation_id(ctx, field, obj)
11670 if res == graphql.Null {
11671 atomic.AddUint32(&invalids, 1)
11672 }
11673 return res
11674 }
11675
11676 out.Concurrently(i, func() graphql.Marshaler {
11677 return innerFunc(ctx)
11678
11679 })
11680 case "author":
11681 field := field
11682
11683 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11684 defer func() {
11685 if r := recover(); r != nil {
11686 ec.Error(ctx, ec.Recover(ctx, r))
11687 }
11688 }()
11689 res = ec._AddCommentOperation_author(ctx, field, obj)
11690 if res == graphql.Null {
11691 atomic.AddUint32(&invalids, 1)
11692 }
11693 return res
11694 }
11695
11696 out.Concurrently(i, func() graphql.Marshaler {
11697 return innerFunc(ctx)
11698
11699 })
11700 case "date":
11701 field := field
11702
11703 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11704 defer func() {
11705 if r := recover(); r != nil {
11706 ec.Error(ctx, ec.Recover(ctx, r))
11707 }
11708 }()
11709 res = ec._AddCommentOperation_date(ctx, field, obj)
11710 if res == graphql.Null {
11711 atomic.AddUint32(&invalids, 1)
11712 }
11713 return res
11714 }
11715
11716 out.Concurrently(i, func() graphql.Marshaler {
11717 return innerFunc(ctx)
11718
11719 })
11720 case "message":
11721 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11722 return ec._AddCommentOperation_message(ctx, field, obj)
11723 }
11724
11725 out.Values[i] = innerFunc(ctx)
11726
11727 if out.Values[i] == graphql.Null {
11728 atomic.AddUint32(&invalids, 1)
11729 }
11730 case "files":
11731 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11732 return ec._AddCommentOperation_files(ctx, field, obj)
11733 }
11734
11735 out.Values[i] = innerFunc(ctx)
11736
11737 if out.Values[i] == graphql.Null {
11738 atomic.AddUint32(&invalids, 1)
11739 }
11740 default:
11741 panic("unknown field " + strconv.Quote(field.Name))
11742 }
11743 }
11744 out.Dispatch()
11745 if invalids > 0 {
11746 return graphql.Null
11747 }
11748 return out
11749}
11750
11751var addCommentPayloadImplementors = []string{"AddCommentPayload"}
11752
11753func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
11754 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
11755 out := graphql.NewFieldSet(fields)
11756 var invalids uint32
11757 for i, field := range fields {
11758 switch field.Name {
11759 case "__typename":
11760 out.Values[i] = graphql.MarshalString("AddCommentPayload")
11761 case "clientMutationId":
11762 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11763 return ec._AddCommentPayload_clientMutationId(ctx, field, obj)
11764 }
11765
11766 out.Values[i] = innerFunc(ctx)
11767
11768 case "bug":
11769 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11770 return ec._AddCommentPayload_bug(ctx, field, obj)
11771 }
11772
11773 out.Values[i] = innerFunc(ctx)
11774
11775 if out.Values[i] == graphql.Null {
11776 invalids++
11777 }
11778 case "operation":
11779 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11780 return ec._AddCommentPayload_operation(ctx, field, obj)
11781 }
11782
11783 out.Values[i] = innerFunc(ctx)
11784
11785 if out.Values[i] == graphql.Null {
11786 invalids++
11787 }
11788 default:
11789 panic("unknown field " + strconv.Quote(field.Name))
11790 }
11791 }
11792 out.Dispatch()
11793 if invalids > 0 {
11794 return graphql.Null
11795 }
11796 return out
11797}
11798
11799var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
11800
11801func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
11802 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
11803 out := graphql.NewFieldSet(fields)
11804 var invalids uint32
11805 for i, field := range fields {
11806 switch field.Name {
11807 case "__typename":
11808 out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
11809 case "id":
11810 field := field
11811
11812 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11813 defer func() {
11814 if r := recover(); r != nil {
11815 ec.Error(ctx, ec.Recover(ctx, r))
11816 }
11817 }()
11818 res = ec._AddCommentTimelineItem_id(ctx, field, obj)
11819 if res == graphql.Null {
11820 atomic.AddUint32(&invalids, 1)
11821 }
11822 return res
11823 }
11824
11825 out.Concurrently(i, func() graphql.Marshaler {
11826 return innerFunc(ctx)
11827
11828 })
11829 case "author":
11830 field := field
11831
11832 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11833 defer func() {
11834 if r := recover(); r != nil {
11835 ec.Error(ctx, ec.Recover(ctx, r))
11836 }
11837 }()
11838 res = ec._AddCommentTimelineItem_author(ctx, field, obj)
11839 if res == graphql.Null {
11840 atomic.AddUint32(&invalids, 1)
11841 }
11842 return res
11843 }
11844
11845 out.Concurrently(i, func() graphql.Marshaler {
11846 return innerFunc(ctx)
11847
11848 })
11849 case "message":
11850 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11851 return ec._AddCommentTimelineItem_message(ctx, field, obj)
11852 }
11853
11854 out.Values[i] = innerFunc(ctx)
11855
11856 if out.Values[i] == graphql.Null {
11857 atomic.AddUint32(&invalids, 1)
11858 }
11859 case "messageIsEmpty":
11860 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11861 return ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
11862 }
11863
11864 out.Values[i] = innerFunc(ctx)
11865
11866 if out.Values[i] == graphql.Null {
11867 atomic.AddUint32(&invalids, 1)
11868 }
11869 case "files":
11870 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11871 return ec._AddCommentTimelineItem_files(ctx, field, obj)
11872 }
11873
11874 out.Values[i] = innerFunc(ctx)
11875
11876 if out.Values[i] == graphql.Null {
11877 atomic.AddUint32(&invalids, 1)
11878 }
11879 case "createdAt":
11880 field := field
11881
11882 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11883 defer func() {
11884 if r := recover(); r != nil {
11885 ec.Error(ctx, ec.Recover(ctx, r))
11886 }
11887 }()
11888 res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
11889 if res == graphql.Null {
11890 atomic.AddUint32(&invalids, 1)
11891 }
11892 return res
11893 }
11894
11895 out.Concurrently(i, func() graphql.Marshaler {
11896 return innerFunc(ctx)
11897
11898 })
11899 case "lastEdit":
11900 field := field
11901
11902 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11903 defer func() {
11904 if r := recover(); r != nil {
11905 ec.Error(ctx, ec.Recover(ctx, r))
11906 }
11907 }()
11908 res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
11909 if res == graphql.Null {
11910 atomic.AddUint32(&invalids, 1)
11911 }
11912 return res
11913 }
11914
11915 out.Concurrently(i, func() graphql.Marshaler {
11916 return innerFunc(ctx)
11917
11918 })
11919 case "edited":
11920 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11921 return ec._AddCommentTimelineItem_edited(ctx, field, obj)
11922 }
11923
11924 out.Values[i] = innerFunc(ctx)
11925
11926 if out.Values[i] == graphql.Null {
11927 atomic.AddUint32(&invalids, 1)
11928 }
11929 case "history":
11930 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11931 return ec._AddCommentTimelineItem_history(ctx, field, obj)
11932 }
11933
11934 out.Values[i] = innerFunc(ctx)
11935
11936 if out.Values[i] == graphql.Null {
11937 atomic.AddUint32(&invalids, 1)
11938 }
11939 default:
11940 panic("unknown field " + strconv.Quote(field.Name))
11941 }
11942 }
11943 out.Dispatch()
11944 if invalids > 0 {
11945 return graphql.Null
11946 }
11947 return out
11948}
11949
11950var bugImplementors = []string{"Bug", "Authored"}
11951
11952func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
11953 fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
11954 out := graphql.NewFieldSet(fields)
11955 var invalids uint32
11956 for i, field := range fields {
11957 switch field.Name {
11958 case "__typename":
11959 out.Values[i] = graphql.MarshalString("Bug")
11960 case "id":
11961 field := field
11962
11963 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11964 defer func() {
11965 if r := recover(); r != nil {
11966 ec.Error(ctx, ec.Recover(ctx, r))
11967 }
11968 }()
11969 res = ec._Bug_id(ctx, field, obj)
11970 if res == graphql.Null {
11971 atomic.AddUint32(&invalids, 1)
11972 }
11973 return res
11974 }
11975
11976 out.Concurrently(i, func() graphql.Marshaler {
11977 return innerFunc(ctx)
11978
11979 })
11980 case "humanId":
11981 field := field
11982
11983 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
11984 defer func() {
11985 if r := recover(); r != nil {
11986 ec.Error(ctx, ec.Recover(ctx, r))
11987 }
11988 }()
11989 res = ec._Bug_humanId(ctx, field, obj)
11990 if res == graphql.Null {
11991 atomic.AddUint32(&invalids, 1)
11992 }
11993 return res
11994 }
11995
11996 out.Concurrently(i, func() graphql.Marshaler {
11997 return innerFunc(ctx)
11998
11999 })
12000 case "status":
12001 field := field
12002
12003 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12004 defer func() {
12005 if r := recover(); r != nil {
12006 ec.Error(ctx, ec.Recover(ctx, r))
12007 }
12008 }()
12009 res = ec._Bug_status(ctx, field, obj)
12010 if res == graphql.Null {
12011 atomic.AddUint32(&invalids, 1)
12012 }
12013 return res
12014 }
12015
12016 out.Concurrently(i, func() graphql.Marshaler {
12017 return innerFunc(ctx)
12018
12019 })
12020 case "title":
12021 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12022 return ec._Bug_title(ctx, field, obj)
12023 }
12024
12025 out.Values[i] = innerFunc(ctx)
12026
12027 if out.Values[i] == graphql.Null {
12028 atomic.AddUint32(&invalids, 1)
12029 }
12030 case "labels":
12031 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12032 return ec._Bug_labels(ctx, field, obj)
12033 }
12034
12035 out.Values[i] = innerFunc(ctx)
12036
12037 if out.Values[i] == graphql.Null {
12038 atomic.AddUint32(&invalids, 1)
12039 }
12040 case "author":
12041 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12042 return ec._Bug_author(ctx, field, obj)
12043 }
12044
12045 out.Values[i] = innerFunc(ctx)
12046
12047 if out.Values[i] == graphql.Null {
12048 atomic.AddUint32(&invalids, 1)
12049 }
12050 case "createdAt":
12051 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12052 return ec._Bug_createdAt(ctx, field, obj)
12053 }
12054
12055 out.Values[i] = innerFunc(ctx)
12056
12057 if out.Values[i] == graphql.Null {
12058 atomic.AddUint32(&invalids, 1)
12059 }
12060 case "lastEdit":
12061 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12062 return ec._Bug_lastEdit(ctx, field, obj)
12063 }
12064
12065 out.Values[i] = innerFunc(ctx)
12066
12067 if out.Values[i] == graphql.Null {
12068 atomic.AddUint32(&invalids, 1)
12069 }
12070 case "actors":
12071 field := field
12072
12073 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12074 defer func() {
12075 if r := recover(); r != nil {
12076 ec.Error(ctx, ec.Recover(ctx, r))
12077 }
12078 }()
12079 res = ec._Bug_actors(ctx, field, obj)
12080 if res == graphql.Null {
12081 atomic.AddUint32(&invalids, 1)
12082 }
12083 return res
12084 }
12085
12086 out.Concurrently(i, func() graphql.Marshaler {
12087 return innerFunc(ctx)
12088
12089 })
12090 case "participants":
12091 field := field
12092
12093 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12094 defer func() {
12095 if r := recover(); r != nil {
12096 ec.Error(ctx, ec.Recover(ctx, r))
12097 }
12098 }()
12099 res = ec._Bug_participants(ctx, field, obj)
12100 if res == graphql.Null {
12101 atomic.AddUint32(&invalids, 1)
12102 }
12103 return res
12104 }
12105
12106 out.Concurrently(i, func() graphql.Marshaler {
12107 return innerFunc(ctx)
12108
12109 })
12110 case "comments":
12111 field := field
12112
12113 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12114 defer func() {
12115 if r := recover(); r != nil {
12116 ec.Error(ctx, ec.Recover(ctx, r))
12117 }
12118 }()
12119 res = ec._Bug_comments(ctx, field, obj)
12120 if res == graphql.Null {
12121 atomic.AddUint32(&invalids, 1)
12122 }
12123 return res
12124 }
12125
12126 out.Concurrently(i, func() graphql.Marshaler {
12127 return innerFunc(ctx)
12128
12129 })
12130 case "timeline":
12131 field := field
12132
12133 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12134 defer func() {
12135 if r := recover(); r != nil {
12136 ec.Error(ctx, ec.Recover(ctx, r))
12137 }
12138 }()
12139 res = ec._Bug_timeline(ctx, field, obj)
12140 if res == graphql.Null {
12141 atomic.AddUint32(&invalids, 1)
12142 }
12143 return res
12144 }
12145
12146 out.Concurrently(i, func() graphql.Marshaler {
12147 return innerFunc(ctx)
12148
12149 })
12150 case "operations":
12151 field := field
12152
12153 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12154 defer func() {
12155 if r := recover(); r != nil {
12156 ec.Error(ctx, ec.Recover(ctx, r))
12157 }
12158 }()
12159 res = ec._Bug_operations(ctx, field, obj)
12160 if res == graphql.Null {
12161 atomic.AddUint32(&invalids, 1)
12162 }
12163 return res
12164 }
12165
12166 out.Concurrently(i, func() graphql.Marshaler {
12167 return innerFunc(ctx)
12168
12169 })
12170 default:
12171 panic("unknown field " + strconv.Quote(field.Name))
12172 }
12173 }
12174 out.Dispatch()
12175 if invalids > 0 {
12176 return graphql.Null
12177 }
12178 return out
12179}
12180
12181var bugConnectionImplementors = []string{"BugConnection"}
12182
12183func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
12184 fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
12185 out := graphql.NewFieldSet(fields)
12186 var invalids uint32
12187 for i, field := range fields {
12188 switch field.Name {
12189 case "__typename":
12190 out.Values[i] = graphql.MarshalString("BugConnection")
12191 case "edges":
12192 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12193 return ec._BugConnection_edges(ctx, field, obj)
12194 }
12195
12196 out.Values[i] = innerFunc(ctx)
12197
12198 if out.Values[i] == graphql.Null {
12199 invalids++
12200 }
12201 case "nodes":
12202 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12203 return ec._BugConnection_nodes(ctx, field, obj)
12204 }
12205
12206 out.Values[i] = innerFunc(ctx)
12207
12208 if out.Values[i] == graphql.Null {
12209 invalids++
12210 }
12211 case "pageInfo":
12212 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12213 return ec._BugConnection_pageInfo(ctx, field, obj)
12214 }
12215
12216 out.Values[i] = innerFunc(ctx)
12217
12218 if out.Values[i] == graphql.Null {
12219 invalids++
12220 }
12221 case "totalCount":
12222 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12223 return ec._BugConnection_totalCount(ctx, field, obj)
12224 }
12225
12226 out.Values[i] = innerFunc(ctx)
12227
12228 if out.Values[i] == graphql.Null {
12229 invalids++
12230 }
12231 default:
12232 panic("unknown field " + strconv.Quote(field.Name))
12233 }
12234 }
12235 out.Dispatch()
12236 if invalids > 0 {
12237 return graphql.Null
12238 }
12239 return out
12240}
12241
12242var bugEdgeImplementors = []string{"BugEdge"}
12243
12244func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
12245 fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
12246 out := graphql.NewFieldSet(fields)
12247 var invalids uint32
12248 for i, field := range fields {
12249 switch field.Name {
12250 case "__typename":
12251 out.Values[i] = graphql.MarshalString("BugEdge")
12252 case "cursor":
12253 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12254 return ec._BugEdge_cursor(ctx, field, obj)
12255 }
12256
12257 out.Values[i] = innerFunc(ctx)
12258
12259 if out.Values[i] == graphql.Null {
12260 invalids++
12261 }
12262 case "node":
12263 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12264 return ec._BugEdge_node(ctx, field, obj)
12265 }
12266
12267 out.Values[i] = innerFunc(ctx)
12268
12269 if out.Values[i] == graphql.Null {
12270 invalids++
12271 }
12272 default:
12273 panic("unknown field " + strconv.Quote(field.Name))
12274 }
12275 }
12276 out.Dispatch()
12277 if invalids > 0 {
12278 return graphql.Null
12279 }
12280 return out
12281}
12282
12283var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
12284
12285func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
12286 fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
12287 out := graphql.NewFieldSet(fields)
12288 var invalids uint32
12289 for i, field := range fields {
12290 switch field.Name {
12291 case "__typename":
12292 out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
12293 case "clientMutationId":
12294 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12295 return ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
12296 }
12297
12298 out.Values[i] = innerFunc(ctx)
12299
12300 case "bug":
12301 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12302 return ec._ChangeLabelPayload_bug(ctx, field, obj)
12303 }
12304
12305 out.Values[i] = innerFunc(ctx)
12306
12307 if out.Values[i] == graphql.Null {
12308 invalids++
12309 }
12310 case "operation":
12311 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12312 return ec._ChangeLabelPayload_operation(ctx, field, obj)
12313 }
12314
12315 out.Values[i] = innerFunc(ctx)
12316
12317 if out.Values[i] == graphql.Null {
12318 invalids++
12319 }
12320 case "results":
12321 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12322 return ec._ChangeLabelPayload_results(ctx, field, obj)
12323 }
12324
12325 out.Values[i] = innerFunc(ctx)
12326
12327 if out.Values[i] == graphql.Null {
12328 invalids++
12329 }
12330 default:
12331 panic("unknown field " + strconv.Quote(field.Name))
12332 }
12333 }
12334 out.Dispatch()
12335 if invalids > 0 {
12336 return graphql.Null
12337 }
12338 return out
12339}
12340
12341var closeBugPayloadImplementors = []string{"CloseBugPayload"}
12342
12343func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
12344 fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
12345 out := graphql.NewFieldSet(fields)
12346 var invalids uint32
12347 for i, field := range fields {
12348 switch field.Name {
12349 case "__typename":
12350 out.Values[i] = graphql.MarshalString("CloseBugPayload")
12351 case "clientMutationId":
12352 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12353 return ec._CloseBugPayload_clientMutationId(ctx, field, obj)
12354 }
12355
12356 out.Values[i] = innerFunc(ctx)
12357
12358 case "bug":
12359 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12360 return ec._CloseBugPayload_bug(ctx, field, obj)
12361 }
12362
12363 out.Values[i] = innerFunc(ctx)
12364
12365 if out.Values[i] == graphql.Null {
12366 invalids++
12367 }
12368 case "operation":
12369 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12370 return ec._CloseBugPayload_operation(ctx, field, obj)
12371 }
12372
12373 out.Values[i] = innerFunc(ctx)
12374
12375 if out.Values[i] == graphql.Null {
12376 invalids++
12377 }
12378 default:
12379 panic("unknown field " + strconv.Quote(field.Name))
12380 }
12381 }
12382 out.Dispatch()
12383 if invalids > 0 {
12384 return graphql.Null
12385 }
12386 return out
12387}
12388
12389var colorImplementors = []string{"Color"}
12390
12391func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
12392 fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
12393 out := graphql.NewFieldSet(fields)
12394 var invalids uint32
12395 for i, field := range fields {
12396 switch field.Name {
12397 case "__typename":
12398 out.Values[i] = graphql.MarshalString("Color")
12399 case "R":
12400 field := field
12401
12402 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12403 defer func() {
12404 if r := recover(); r != nil {
12405 ec.Error(ctx, ec.Recover(ctx, r))
12406 }
12407 }()
12408 res = ec._Color_R(ctx, field, obj)
12409 if res == graphql.Null {
12410 atomic.AddUint32(&invalids, 1)
12411 }
12412 return res
12413 }
12414
12415 out.Concurrently(i, func() graphql.Marshaler {
12416 return innerFunc(ctx)
12417
12418 })
12419 case "G":
12420 field := field
12421
12422 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12423 defer func() {
12424 if r := recover(); r != nil {
12425 ec.Error(ctx, ec.Recover(ctx, r))
12426 }
12427 }()
12428 res = ec._Color_G(ctx, field, obj)
12429 if res == graphql.Null {
12430 atomic.AddUint32(&invalids, 1)
12431 }
12432 return res
12433 }
12434
12435 out.Concurrently(i, func() graphql.Marshaler {
12436 return innerFunc(ctx)
12437
12438 })
12439 case "B":
12440 field := field
12441
12442 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12443 defer func() {
12444 if r := recover(); r != nil {
12445 ec.Error(ctx, ec.Recover(ctx, r))
12446 }
12447 }()
12448 res = ec._Color_B(ctx, field, obj)
12449 if res == graphql.Null {
12450 atomic.AddUint32(&invalids, 1)
12451 }
12452 return res
12453 }
12454
12455 out.Concurrently(i, func() graphql.Marshaler {
12456 return innerFunc(ctx)
12457
12458 })
12459 default:
12460 panic("unknown field " + strconv.Quote(field.Name))
12461 }
12462 }
12463 out.Dispatch()
12464 if invalids > 0 {
12465 return graphql.Null
12466 }
12467 return out
12468}
12469
12470var commentImplementors = []string{"Comment", "Authored"}
12471
12472func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
12473 fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
12474 out := graphql.NewFieldSet(fields)
12475 var invalids uint32
12476 for i, field := range fields {
12477 switch field.Name {
12478 case "__typename":
12479 out.Values[i] = graphql.MarshalString("Comment")
12480 case "author":
12481 field := field
12482
12483 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12484 defer func() {
12485 if r := recover(); r != nil {
12486 ec.Error(ctx, ec.Recover(ctx, r))
12487 }
12488 }()
12489 res = ec._Comment_author(ctx, field, obj)
12490 if res == graphql.Null {
12491 atomic.AddUint32(&invalids, 1)
12492 }
12493 return res
12494 }
12495
12496 out.Concurrently(i, func() graphql.Marshaler {
12497 return innerFunc(ctx)
12498
12499 })
12500 case "message":
12501 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12502 return ec._Comment_message(ctx, field, obj)
12503 }
12504
12505 out.Values[i] = innerFunc(ctx)
12506
12507 if out.Values[i] == graphql.Null {
12508 atomic.AddUint32(&invalids, 1)
12509 }
12510 case "files":
12511 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12512 return ec._Comment_files(ctx, field, obj)
12513 }
12514
12515 out.Values[i] = innerFunc(ctx)
12516
12517 if out.Values[i] == graphql.Null {
12518 atomic.AddUint32(&invalids, 1)
12519 }
12520 default:
12521 panic("unknown field " + strconv.Quote(field.Name))
12522 }
12523 }
12524 out.Dispatch()
12525 if invalids > 0 {
12526 return graphql.Null
12527 }
12528 return out
12529}
12530
12531var commentConnectionImplementors = []string{"CommentConnection"}
12532
12533func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
12534 fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
12535 out := graphql.NewFieldSet(fields)
12536 var invalids uint32
12537 for i, field := range fields {
12538 switch field.Name {
12539 case "__typename":
12540 out.Values[i] = graphql.MarshalString("CommentConnection")
12541 case "edges":
12542 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12543 return ec._CommentConnection_edges(ctx, field, obj)
12544 }
12545
12546 out.Values[i] = innerFunc(ctx)
12547
12548 if out.Values[i] == graphql.Null {
12549 invalids++
12550 }
12551 case "nodes":
12552 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12553 return ec._CommentConnection_nodes(ctx, field, obj)
12554 }
12555
12556 out.Values[i] = innerFunc(ctx)
12557
12558 if out.Values[i] == graphql.Null {
12559 invalids++
12560 }
12561 case "pageInfo":
12562 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12563 return ec._CommentConnection_pageInfo(ctx, field, obj)
12564 }
12565
12566 out.Values[i] = innerFunc(ctx)
12567
12568 if out.Values[i] == graphql.Null {
12569 invalids++
12570 }
12571 case "totalCount":
12572 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12573 return ec._CommentConnection_totalCount(ctx, field, obj)
12574 }
12575
12576 out.Values[i] = innerFunc(ctx)
12577
12578 if out.Values[i] == graphql.Null {
12579 invalids++
12580 }
12581 default:
12582 panic("unknown field " + strconv.Quote(field.Name))
12583 }
12584 }
12585 out.Dispatch()
12586 if invalids > 0 {
12587 return graphql.Null
12588 }
12589 return out
12590}
12591
12592var commentEdgeImplementors = []string{"CommentEdge"}
12593
12594func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
12595 fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
12596 out := graphql.NewFieldSet(fields)
12597 var invalids uint32
12598 for i, field := range fields {
12599 switch field.Name {
12600 case "__typename":
12601 out.Values[i] = graphql.MarshalString("CommentEdge")
12602 case "cursor":
12603 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12604 return ec._CommentEdge_cursor(ctx, field, obj)
12605 }
12606
12607 out.Values[i] = innerFunc(ctx)
12608
12609 if out.Values[i] == graphql.Null {
12610 invalids++
12611 }
12612 case "node":
12613 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12614 return ec._CommentEdge_node(ctx, field, obj)
12615 }
12616
12617 out.Values[i] = innerFunc(ctx)
12618
12619 if out.Values[i] == graphql.Null {
12620 invalids++
12621 }
12622 default:
12623 panic("unknown field " + strconv.Quote(field.Name))
12624 }
12625 }
12626 out.Dispatch()
12627 if invalids > 0 {
12628 return graphql.Null
12629 }
12630 return out
12631}
12632
12633var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
12634
12635func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
12636 fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
12637 out := graphql.NewFieldSet(fields)
12638 var invalids uint32
12639 for i, field := range fields {
12640 switch field.Name {
12641 case "__typename":
12642 out.Values[i] = graphql.MarshalString("CommentHistoryStep")
12643 case "message":
12644 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12645 return ec._CommentHistoryStep_message(ctx, field, obj)
12646 }
12647
12648 out.Values[i] = innerFunc(ctx)
12649
12650 if out.Values[i] == graphql.Null {
12651 atomic.AddUint32(&invalids, 1)
12652 }
12653 case "date":
12654 field := field
12655
12656 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12657 defer func() {
12658 if r := recover(); r != nil {
12659 ec.Error(ctx, ec.Recover(ctx, r))
12660 }
12661 }()
12662 res = ec._CommentHistoryStep_date(ctx, field, obj)
12663 if res == graphql.Null {
12664 atomic.AddUint32(&invalids, 1)
12665 }
12666 return res
12667 }
12668
12669 out.Concurrently(i, func() graphql.Marshaler {
12670 return innerFunc(ctx)
12671
12672 })
12673 default:
12674 panic("unknown field " + strconv.Quote(field.Name))
12675 }
12676 }
12677 out.Dispatch()
12678 if invalids > 0 {
12679 return graphql.Null
12680 }
12681 return out
12682}
12683
12684var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
12685
12686func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
12687 fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
12688 out := graphql.NewFieldSet(fields)
12689 var invalids uint32
12690 for i, field := range fields {
12691 switch field.Name {
12692 case "__typename":
12693 out.Values[i] = graphql.MarshalString("CreateOperation")
12694 case "id":
12695 field := field
12696
12697 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12698 defer func() {
12699 if r := recover(); r != nil {
12700 ec.Error(ctx, ec.Recover(ctx, r))
12701 }
12702 }()
12703 res = ec._CreateOperation_id(ctx, field, obj)
12704 if res == graphql.Null {
12705 atomic.AddUint32(&invalids, 1)
12706 }
12707 return res
12708 }
12709
12710 out.Concurrently(i, func() graphql.Marshaler {
12711 return innerFunc(ctx)
12712
12713 })
12714 case "author":
12715 field := field
12716
12717 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12718 defer func() {
12719 if r := recover(); r != nil {
12720 ec.Error(ctx, ec.Recover(ctx, r))
12721 }
12722 }()
12723 res = ec._CreateOperation_author(ctx, field, obj)
12724 if res == graphql.Null {
12725 atomic.AddUint32(&invalids, 1)
12726 }
12727 return res
12728 }
12729
12730 out.Concurrently(i, func() graphql.Marshaler {
12731 return innerFunc(ctx)
12732
12733 })
12734 case "date":
12735 field := field
12736
12737 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12738 defer func() {
12739 if r := recover(); r != nil {
12740 ec.Error(ctx, ec.Recover(ctx, r))
12741 }
12742 }()
12743 res = ec._CreateOperation_date(ctx, field, obj)
12744 if res == graphql.Null {
12745 atomic.AddUint32(&invalids, 1)
12746 }
12747 return res
12748 }
12749
12750 out.Concurrently(i, func() graphql.Marshaler {
12751 return innerFunc(ctx)
12752
12753 })
12754 case "title":
12755 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12756 return ec._CreateOperation_title(ctx, field, obj)
12757 }
12758
12759 out.Values[i] = innerFunc(ctx)
12760
12761 if out.Values[i] == graphql.Null {
12762 atomic.AddUint32(&invalids, 1)
12763 }
12764 case "message":
12765 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12766 return ec._CreateOperation_message(ctx, field, obj)
12767 }
12768
12769 out.Values[i] = innerFunc(ctx)
12770
12771 if out.Values[i] == graphql.Null {
12772 atomic.AddUint32(&invalids, 1)
12773 }
12774 case "files":
12775 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12776 return ec._CreateOperation_files(ctx, field, obj)
12777 }
12778
12779 out.Values[i] = innerFunc(ctx)
12780
12781 if out.Values[i] == graphql.Null {
12782 atomic.AddUint32(&invalids, 1)
12783 }
12784 default:
12785 panic("unknown field " + strconv.Quote(field.Name))
12786 }
12787 }
12788 out.Dispatch()
12789 if invalids > 0 {
12790 return graphql.Null
12791 }
12792 return out
12793}
12794
12795var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
12796
12797func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
12798 fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
12799 out := graphql.NewFieldSet(fields)
12800 var invalids uint32
12801 for i, field := range fields {
12802 switch field.Name {
12803 case "__typename":
12804 out.Values[i] = graphql.MarshalString("CreateTimelineItem")
12805 case "id":
12806 field := field
12807
12808 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12809 defer func() {
12810 if r := recover(); r != nil {
12811 ec.Error(ctx, ec.Recover(ctx, r))
12812 }
12813 }()
12814 res = ec._CreateTimelineItem_id(ctx, field, obj)
12815 if res == graphql.Null {
12816 atomic.AddUint32(&invalids, 1)
12817 }
12818 return res
12819 }
12820
12821 out.Concurrently(i, func() graphql.Marshaler {
12822 return innerFunc(ctx)
12823
12824 })
12825 case "author":
12826 field := field
12827
12828 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12829 defer func() {
12830 if r := recover(); r != nil {
12831 ec.Error(ctx, ec.Recover(ctx, r))
12832 }
12833 }()
12834 res = ec._CreateTimelineItem_author(ctx, field, obj)
12835 if res == graphql.Null {
12836 atomic.AddUint32(&invalids, 1)
12837 }
12838 return res
12839 }
12840
12841 out.Concurrently(i, func() graphql.Marshaler {
12842 return innerFunc(ctx)
12843
12844 })
12845 case "message":
12846 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12847 return ec._CreateTimelineItem_message(ctx, field, obj)
12848 }
12849
12850 out.Values[i] = innerFunc(ctx)
12851
12852 if out.Values[i] == graphql.Null {
12853 atomic.AddUint32(&invalids, 1)
12854 }
12855 case "messageIsEmpty":
12856 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12857 return ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
12858 }
12859
12860 out.Values[i] = innerFunc(ctx)
12861
12862 if out.Values[i] == graphql.Null {
12863 atomic.AddUint32(&invalids, 1)
12864 }
12865 case "files":
12866 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12867 return ec._CreateTimelineItem_files(ctx, field, obj)
12868 }
12869
12870 out.Values[i] = innerFunc(ctx)
12871
12872 if out.Values[i] == graphql.Null {
12873 atomic.AddUint32(&invalids, 1)
12874 }
12875 case "createdAt":
12876 field := field
12877
12878 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12879 defer func() {
12880 if r := recover(); r != nil {
12881 ec.Error(ctx, ec.Recover(ctx, r))
12882 }
12883 }()
12884 res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
12885 if res == graphql.Null {
12886 atomic.AddUint32(&invalids, 1)
12887 }
12888 return res
12889 }
12890
12891 out.Concurrently(i, func() graphql.Marshaler {
12892 return innerFunc(ctx)
12893
12894 })
12895 case "lastEdit":
12896 field := field
12897
12898 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12899 defer func() {
12900 if r := recover(); r != nil {
12901 ec.Error(ctx, ec.Recover(ctx, r))
12902 }
12903 }()
12904 res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
12905 if res == graphql.Null {
12906 atomic.AddUint32(&invalids, 1)
12907 }
12908 return res
12909 }
12910
12911 out.Concurrently(i, func() graphql.Marshaler {
12912 return innerFunc(ctx)
12913
12914 })
12915 case "edited":
12916 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12917 return ec._CreateTimelineItem_edited(ctx, field, obj)
12918 }
12919
12920 out.Values[i] = innerFunc(ctx)
12921
12922 if out.Values[i] == graphql.Null {
12923 atomic.AddUint32(&invalids, 1)
12924 }
12925 case "history":
12926 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12927 return ec._CreateTimelineItem_history(ctx, field, obj)
12928 }
12929
12930 out.Values[i] = innerFunc(ctx)
12931
12932 if out.Values[i] == graphql.Null {
12933 atomic.AddUint32(&invalids, 1)
12934 }
12935 default:
12936 panic("unknown field " + strconv.Quote(field.Name))
12937 }
12938 }
12939 out.Dispatch()
12940 if invalids > 0 {
12941 return graphql.Null
12942 }
12943 return out
12944}
12945
12946var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
12947
12948func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
12949 fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
12950 out := graphql.NewFieldSet(fields)
12951 var invalids uint32
12952 for i, field := range fields {
12953 switch field.Name {
12954 case "__typename":
12955 out.Values[i] = graphql.MarshalString("EditCommentOperation")
12956 case "id":
12957 field := field
12958
12959 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12960 defer func() {
12961 if r := recover(); r != nil {
12962 ec.Error(ctx, ec.Recover(ctx, r))
12963 }
12964 }()
12965 res = ec._EditCommentOperation_id(ctx, field, obj)
12966 if res == graphql.Null {
12967 atomic.AddUint32(&invalids, 1)
12968 }
12969 return res
12970 }
12971
12972 out.Concurrently(i, func() graphql.Marshaler {
12973 return innerFunc(ctx)
12974
12975 })
12976 case "author":
12977 field := field
12978
12979 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
12980 defer func() {
12981 if r := recover(); r != nil {
12982 ec.Error(ctx, ec.Recover(ctx, r))
12983 }
12984 }()
12985 res = ec._EditCommentOperation_author(ctx, field, obj)
12986 if res == graphql.Null {
12987 atomic.AddUint32(&invalids, 1)
12988 }
12989 return res
12990 }
12991
12992 out.Concurrently(i, func() graphql.Marshaler {
12993 return innerFunc(ctx)
12994
12995 })
12996 case "date":
12997 field := field
12998
12999 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13000 defer func() {
13001 if r := recover(); r != nil {
13002 ec.Error(ctx, ec.Recover(ctx, r))
13003 }
13004 }()
13005 res = ec._EditCommentOperation_date(ctx, field, obj)
13006 if res == graphql.Null {
13007 atomic.AddUint32(&invalids, 1)
13008 }
13009 return res
13010 }
13011
13012 out.Concurrently(i, func() graphql.Marshaler {
13013 return innerFunc(ctx)
13014
13015 })
13016 case "target":
13017 field := field
13018
13019 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13020 defer func() {
13021 if r := recover(); r != nil {
13022 ec.Error(ctx, ec.Recover(ctx, r))
13023 }
13024 }()
13025 res = ec._EditCommentOperation_target(ctx, field, obj)
13026 if res == graphql.Null {
13027 atomic.AddUint32(&invalids, 1)
13028 }
13029 return res
13030 }
13031
13032 out.Concurrently(i, func() graphql.Marshaler {
13033 return innerFunc(ctx)
13034
13035 })
13036 case "message":
13037 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13038 return ec._EditCommentOperation_message(ctx, field, obj)
13039 }
13040
13041 out.Values[i] = innerFunc(ctx)
13042
13043 if out.Values[i] == graphql.Null {
13044 atomic.AddUint32(&invalids, 1)
13045 }
13046 case "files":
13047 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13048 return ec._EditCommentOperation_files(ctx, field, obj)
13049 }
13050
13051 out.Values[i] = innerFunc(ctx)
13052
13053 if out.Values[i] == graphql.Null {
13054 atomic.AddUint32(&invalids, 1)
13055 }
13056 default:
13057 panic("unknown field " + strconv.Quote(field.Name))
13058 }
13059 }
13060 out.Dispatch()
13061 if invalids > 0 {
13062 return graphql.Null
13063 }
13064 return out
13065}
13066
13067var editCommentPayloadImplementors = []string{"EditCommentPayload"}
13068
13069func (ec *executionContext) _EditCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.EditCommentPayload) graphql.Marshaler {
13070 fields := graphql.CollectFields(ec.OperationContext, sel, editCommentPayloadImplementors)
13071 out := graphql.NewFieldSet(fields)
13072 var invalids uint32
13073 for i, field := range fields {
13074 switch field.Name {
13075 case "__typename":
13076 out.Values[i] = graphql.MarshalString("EditCommentPayload")
13077 case "clientMutationId":
13078 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13079 return ec._EditCommentPayload_clientMutationId(ctx, field, obj)
13080 }
13081
13082 out.Values[i] = innerFunc(ctx)
13083
13084 case "bug":
13085 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13086 return ec._EditCommentPayload_bug(ctx, field, obj)
13087 }
13088
13089 out.Values[i] = innerFunc(ctx)
13090
13091 if out.Values[i] == graphql.Null {
13092 invalids++
13093 }
13094 case "operation":
13095 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13096 return ec._EditCommentPayload_operation(ctx, field, obj)
13097 }
13098
13099 out.Values[i] = innerFunc(ctx)
13100
13101 if out.Values[i] == graphql.Null {
13102 invalids++
13103 }
13104 default:
13105 panic("unknown field " + strconv.Quote(field.Name))
13106 }
13107 }
13108 out.Dispatch()
13109 if invalids > 0 {
13110 return graphql.Null
13111 }
13112 return out
13113}
13114
13115var identityImplementors = []string{"Identity"}
13116
13117func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj models.IdentityWrapper) graphql.Marshaler {
13118 fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
13119 out := graphql.NewFieldSet(fields)
13120 var invalids uint32
13121 for i, field := range fields {
13122 switch field.Name {
13123 case "__typename":
13124 out.Values[i] = graphql.MarshalString("Identity")
13125 case "id":
13126 field := field
13127
13128 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13129 defer func() {
13130 if r := recover(); r != nil {
13131 ec.Error(ctx, ec.Recover(ctx, r))
13132 }
13133 }()
13134 res = ec._Identity_id(ctx, field, obj)
13135 if res == graphql.Null {
13136 atomic.AddUint32(&invalids, 1)
13137 }
13138 return res
13139 }
13140
13141 out.Concurrently(i, func() graphql.Marshaler {
13142 return innerFunc(ctx)
13143
13144 })
13145 case "humanId":
13146 field := field
13147
13148 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13149 defer func() {
13150 if r := recover(); r != nil {
13151 ec.Error(ctx, ec.Recover(ctx, r))
13152 }
13153 }()
13154 res = ec._Identity_humanId(ctx, field, obj)
13155 if res == graphql.Null {
13156 atomic.AddUint32(&invalids, 1)
13157 }
13158 return res
13159 }
13160
13161 out.Concurrently(i, func() graphql.Marshaler {
13162 return innerFunc(ctx)
13163
13164 })
13165 case "name":
13166 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13167 return ec._Identity_name(ctx, field, obj)
13168 }
13169
13170 out.Values[i] = innerFunc(ctx)
13171
13172 case "email":
13173 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13174 return ec._Identity_email(ctx, field, obj)
13175 }
13176
13177 out.Values[i] = innerFunc(ctx)
13178
13179 case "login":
13180 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13181 return ec._Identity_login(ctx, field, obj)
13182 }
13183
13184 out.Values[i] = innerFunc(ctx)
13185
13186 case "displayName":
13187 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13188 return ec._Identity_displayName(ctx, field, obj)
13189 }
13190
13191 out.Values[i] = innerFunc(ctx)
13192
13193 if out.Values[i] == graphql.Null {
13194 atomic.AddUint32(&invalids, 1)
13195 }
13196 case "avatarUrl":
13197 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13198 return ec._Identity_avatarUrl(ctx, field, obj)
13199 }
13200
13201 out.Values[i] = innerFunc(ctx)
13202
13203 case "isProtected":
13204 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13205 return ec._Identity_isProtected(ctx, field, obj)
13206 }
13207
13208 out.Values[i] = innerFunc(ctx)
13209
13210 if out.Values[i] == graphql.Null {
13211 atomic.AddUint32(&invalids, 1)
13212 }
13213 default:
13214 panic("unknown field " + strconv.Quote(field.Name))
13215 }
13216 }
13217 out.Dispatch()
13218 if invalids > 0 {
13219 return graphql.Null
13220 }
13221 return out
13222}
13223
13224var identityConnectionImplementors = []string{"IdentityConnection"}
13225
13226func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
13227 fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
13228 out := graphql.NewFieldSet(fields)
13229 var invalids uint32
13230 for i, field := range fields {
13231 switch field.Name {
13232 case "__typename":
13233 out.Values[i] = graphql.MarshalString("IdentityConnection")
13234 case "edges":
13235 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13236 return ec._IdentityConnection_edges(ctx, field, obj)
13237 }
13238
13239 out.Values[i] = innerFunc(ctx)
13240
13241 if out.Values[i] == graphql.Null {
13242 invalids++
13243 }
13244 case "nodes":
13245 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13246 return ec._IdentityConnection_nodes(ctx, field, obj)
13247 }
13248
13249 out.Values[i] = innerFunc(ctx)
13250
13251 if out.Values[i] == graphql.Null {
13252 invalids++
13253 }
13254 case "pageInfo":
13255 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13256 return ec._IdentityConnection_pageInfo(ctx, field, obj)
13257 }
13258
13259 out.Values[i] = innerFunc(ctx)
13260
13261 if out.Values[i] == graphql.Null {
13262 invalids++
13263 }
13264 case "totalCount":
13265 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13266 return ec._IdentityConnection_totalCount(ctx, field, obj)
13267 }
13268
13269 out.Values[i] = innerFunc(ctx)
13270
13271 if out.Values[i] == graphql.Null {
13272 invalids++
13273 }
13274 default:
13275 panic("unknown field " + strconv.Quote(field.Name))
13276 }
13277 }
13278 out.Dispatch()
13279 if invalids > 0 {
13280 return graphql.Null
13281 }
13282 return out
13283}
13284
13285var identityEdgeImplementors = []string{"IdentityEdge"}
13286
13287func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
13288 fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
13289 out := graphql.NewFieldSet(fields)
13290 var invalids uint32
13291 for i, field := range fields {
13292 switch field.Name {
13293 case "__typename":
13294 out.Values[i] = graphql.MarshalString("IdentityEdge")
13295 case "cursor":
13296 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13297 return ec._IdentityEdge_cursor(ctx, field, obj)
13298 }
13299
13300 out.Values[i] = innerFunc(ctx)
13301
13302 if out.Values[i] == graphql.Null {
13303 invalids++
13304 }
13305 case "node":
13306 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13307 return ec._IdentityEdge_node(ctx, field, obj)
13308 }
13309
13310 out.Values[i] = innerFunc(ctx)
13311
13312 if out.Values[i] == graphql.Null {
13313 invalids++
13314 }
13315 default:
13316 panic("unknown field " + strconv.Quote(field.Name))
13317 }
13318 }
13319 out.Dispatch()
13320 if invalids > 0 {
13321 return graphql.Null
13322 }
13323 return out
13324}
13325
13326var labelImplementors = []string{"Label"}
13327
13328func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
13329 fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
13330 out := graphql.NewFieldSet(fields)
13331 var invalids uint32
13332 for i, field := range fields {
13333 switch field.Name {
13334 case "__typename":
13335 out.Values[i] = graphql.MarshalString("Label")
13336 case "name":
13337 field := field
13338
13339 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13340 defer func() {
13341 if r := recover(); r != nil {
13342 ec.Error(ctx, ec.Recover(ctx, r))
13343 }
13344 }()
13345 res = ec._Label_name(ctx, field, obj)
13346 if res == graphql.Null {
13347 atomic.AddUint32(&invalids, 1)
13348 }
13349 return res
13350 }
13351
13352 out.Concurrently(i, func() graphql.Marshaler {
13353 return innerFunc(ctx)
13354
13355 })
13356 case "color":
13357 field := field
13358
13359 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13360 defer func() {
13361 if r := recover(); r != nil {
13362 ec.Error(ctx, ec.Recover(ctx, r))
13363 }
13364 }()
13365 res = ec._Label_color(ctx, field, obj)
13366 if res == graphql.Null {
13367 atomic.AddUint32(&invalids, 1)
13368 }
13369 return res
13370 }
13371
13372 out.Concurrently(i, func() graphql.Marshaler {
13373 return innerFunc(ctx)
13374
13375 })
13376 default:
13377 panic("unknown field " + strconv.Quote(field.Name))
13378 }
13379 }
13380 out.Dispatch()
13381 if invalids > 0 {
13382 return graphql.Null
13383 }
13384 return out
13385}
13386
13387var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
13388
13389func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
13390 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
13391 out := graphql.NewFieldSet(fields)
13392 var invalids uint32
13393 for i, field := range fields {
13394 switch field.Name {
13395 case "__typename":
13396 out.Values[i] = graphql.MarshalString("LabelChangeOperation")
13397 case "id":
13398 field := field
13399
13400 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13401 defer func() {
13402 if r := recover(); r != nil {
13403 ec.Error(ctx, ec.Recover(ctx, r))
13404 }
13405 }()
13406 res = ec._LabelChangeOperation_id(ctx, field, obj)
13407 if res == graphql.Null {
13408 atomic.AddUint32(&invalids, 1)
13409 }
13410 return res
13411 }
13412
13413 out.Concurrently(i, func() graphql.Marshaler {
13414 return innerFunc(ctx)
13415
13416 })
13417 case "author":
13418 field := field
13419
13420 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13421 defer func() {
13422 if r := recover(); r != nil {
13423 ec.Error(ctx, ec.Recover(ctx, r))
13424 }
13425 }()
13426 res = ec._LabelChangeOperation_author(ctx, field, obj)
13427 if res == graphql.Null {
13428 atomic.AddUint32(&invalids, 1)
13429 }
13430 return res
13431 }
13432
13433 out.Concurrently(i, func() graphql.Marshaler {
13434 return innerFunc(ctx)
13435
13436 })
13437 case "date":
13438 field := field
13439
13440 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13441 defer func() {
13442 if r := recover(); r != nil {
13443 ec.Error(ctx, ec.Recover(ctx, r))
13444 }
13445 }()
13446 res = ec._LabelChangeOperation_date(ctx, field, obj)
13447 if res == graphql.Null {
13448 atomic.AddUint32(&invalids, 1)
13449 }
13450 return res
13451 }
13452
13453 out.Concurrently(i, func() graphql.Marshaler {
13454 return innerFunc(ctx)
13455
13456 })
13457 case "added":
13458 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13459 return ec._LabelChangeOperation_added(ctx, field, obj)
13460 }
13461
13462 out.Values[i] = innerFunc(ctx)
13463
13464 if out.Values[i] == graphql.Null {
13465 atomic.AddUint32(&invalids, 1)
13466 }
13467 case "removed":
13468 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13469 return ec._LabelChangeOperation_removed(ctx, field, obj)
13470 }
13471
13472 out.Values[i] = innerFunc(ctx)
13473
13474 if out.Values[i] == graphql.Null {
13475 atomic.AddUint32(&invalids, 1)
13476 }
13477 default:
13478 panic("unknown field " + strconv.Quote(field.Name))
13479 }
13480 }
13481 out.Dispatch()
13482 if invalids > 0 {
13483 return graphql.Null
13484 }
13485 return out
13486}
13487
13488var labelChangeResultImplementors = []string{"LabelChangeResult"}
13489
13490func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
13491 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
13492 out := graphql.NewFieldSet(fields)
13493 var invalids uint32
13494 for i, field := range fields {
13495 switch field.Name {
13496 case "__typename":
13497 out.Values[i] = graphql.MarshalString("LabelChangeResult")
13498 case "label":
13499 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13500 return ec._LabelChangeResult_label(ctx, field, obj)
13501 }
13502
13503 out.Values[i] = innerFunc(ctx)
13504
13505 if out.Values[i] == graphql.Null {
13506 atomic.AddUint32(&invalids, 1)
13507 }
13508 case "status":
13509 field := field
13510
13511 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13512 defer func() {
13513 if r := recover(); r != nil {
13514 ec.Error(ctx, ec.Recover(ctx, r))
13515 }
13516 }()
13517 res = ec._LabelChangeResult_status(ctx, field, obj)
13518 if res == graphql.Null {
13519 atomic.AddUint32(&invalids, 1)
13520 }
13521 return res
13522 }
13523
13524 out.Concurrently(i, func() graphql.Marshaler {
13525 return innerFunc(ctx)
13526
13527 })
13528 default:
13529 panic("unknown field " + strconv.Quote(field.Name))
13530 }
13531 }
13532 out.Dispatch()
13533 if invalids > 0 {
13534 return graphql.Null
13535 }
13536 return out
13537}
13538
13539var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
13540
13541func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
13542 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
13543 out := graphql.NewFieldSet(fields)
13544 var invalids uint32
13545 for i, field := range fields {
13546 switch field.Name {
13547 case "__typename":
13548 out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
13549 case "id":
13550 field := field
13551
13552 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13553 defer func() {
13554 if r := recover(); r != nil {
13555 ec.Error(ctx, ec.Recover(ctx, r))
13556 }
13557 }()
13558 res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
13559 if res == graphql.Null {
13560 atomic.AddUint32(&invalids, 1)
13561 }
13562 return res
13563 }
13564
13565 out.Concurrently(i, func() graphql.Marshaler {
13566 return innerFunc(ctx)
13567
13568 })
13569 case "author":
13570 field := field
13571
13572 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13573 defer func() {
13574 if r := recover(); r != nil {
13575 ec.Error(ctx, ec.Recover(ctx, r))
13576 }
13577 }()
13578 res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
13579 if res == graphql.Null {
13580 atomic.AddUint32(&invalids, 1)
13581 }
13582 return res
13583 }
13584
13585 out.Concurrently(i, func() graphql.Marshaler {
13586 return innerFunc(ctx)
13587
13588 })
13589 case "date":
13590 field := field
13591
13592 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13593 defer func() {
13594 if r := recover(); r != nil {
13595 ec.Error(ctx, ec.Recover(ctx, r))
13596 }
13597 }()
13598 res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
13599 if res == graphql.Null {
13600 atomic.AddUint32(&invalids, 1)
13601 }
13602 return res
13603 }
13604
13605 out.Concurrently(i, func() graphql.Marshaler {
13606 return innerFunc(ctx)
13607
13608 })
13609 case "added":
13610 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13611 return ec._LabelChangeTimelineItem_added(ctx, field, obj)
13612 }
13613
13614 out.Values[i] = innerFunc(ctx)
13615
13616 if out.Values[i] == graphql.Null {
13617 atomic.AddUint32(&invalids, 1)
13618 }
13619 case "removed":
13620 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13621 return ec._LabelChangeTimelineItem_removed(ctx, field, obj)
13622 }
13623
13624 out.Values[i] = innerFunc(ctx)
13625
13626 if out.Values[i] == graphql.Null {
13627 atomic.AddUint32(&invalids, 1)
13628 }
13629 default:
13630 panic("unknown field " + strconv.Quote(field.Name))
13631 }
13632 }
13633 out.Dispatch()
13634 if invalids > 0 {
13635 return graphql.Null
13636 }
13637 return out
13638}
13639
13640var labelConnectionImplementors = []string{"LabelConnection"}
13641
13642func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
13643 fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
13644 out := graphql.NewFieldSet(fields)
13645 var invalids uint32
13646 for i, field := range fields {
13647 switch field.Name {
13648 case "__typename":
13649 out.Values[i] = graphql.MarshalString("LabelConnection")
13650 case "edges":
13651 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13652 return ec._LabelConnection_edges(ctx, field, obj)
13653 }
13654
13655 out.Values[i] = innerFunc(ctx)
13656
13657 if out.Values[i] == graphql.Null {
13658 invalids++
13659 }
13660 case "nodes":
13661 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13662 return ec._LabelConnection_nodes(ctx, field, obj)
13663 }
13664
13665 out.Values[i] = innerFunc(ctx)
13666
13667 if out.Values[i] == graphql.Null {
13668 invalids++
13669 }
13670 case "pageInfo":
13671 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13672 return ec._LabelConnection_pageInfo(ctx, field, obj)
13673 }
13674
13675 out.Values[i] = innerFunc(ctx)
13676
13677 if out.Values[i] == graphql.Null {
13678 invalids++
13679 }
13680 case "totalCount":
13681 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13682 return ec._LabelConnection_totalCount(ctx, field, obj)
13683 }
13684
13685 out.Values[i] = innerFunc(ctx)
13686
13687 if out.Values[i] == graphql.Null {
13688 invalids++
13689 }
13690 default:
13691 panic("unknown field " + strconv.Quote(field.Name))
13692 }
13693 }
13694 out.Dispatch()
13695 if invalids > 0 {
13696 return graphql.Null
13697 }
13698 return out
13699}
13700
13701var labelEdgeImplementors = []string{"LabelEdge"}
13702
13703func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
13704 fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
13705 out := graphql.NewFieldSet(fields)
13706 var invalids uint32
13707 for i, field := range fields {
13708 switch field.Name {
13709 case "__typename":
13710 out.Values[i] = graphql.MarshalString("LabelEdge")
13711 case "cursor":
13712 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13713 return ec._LabelEdge_cursor(ctx, field, obj)
13714 }
13715
13716 out.Values[i] = innerFunc(ctx)
13717
13718 if out.Values[i] == graphql.Null {
13719 invalids++
13720 }
13721 case "node":
13722 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13723 return ec._LabelEdge_node(ctx, field, obj)
13724 }
13725
13726 out.Values[i] = innerFunc(ctx)
13727
13728 if out.Values[i] == graphql.Null {
13729 invalids++
13730 }
13731 default:
13732 panic("unknown field " + strconv.Quote(field.Name))
13733 }
13734 }
13735 out.Dispatch()
13736 if invalids > 0 {
13737 return graphql.Null
13738 }
13739 return out
13740}
13741
13742var mutationImplementors = []string{"Mutation"}
13743
13744func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
13745 fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
13746 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
13747 Object: "Mutation",
13748 })
13749
13750 out := graphql.NewFieldSet(fields)
13751 var invalids uint32
13752 for i, field := range fields {
13753 innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
13754 Object: field.Name,
13755 Field: field,
13756 })
13757
13758 switch field.Name {
13759 case "__typename":
13760 out.Values[i] = graphql.MarshalString("Mutation")
13761 case "newBug":
13762 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13763 return ec._Mutation_newBug(ctx, field)
13764 }
13765
13766 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, innerFunc)
13767
13768 if out.Values[i] == graphql.Null {
13769 invalids++
13770 }
13771 case "addComment":
13772 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13773 return ec._Mutation_addComment(ctx, field)
13774 }
13775
13776 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, innerFunc)
13777
13778 if out.Values[i] == graphql.Null {
13779 invalids++
13780 }
13781 case "addCommentAndClose":
13782 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13783 return ec._Mutation_addCommentAndClose(ctx, field)
13784 }
13785
13786 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, innerFunc)
13787
13788 if out.Values[i] == graphql.Null {
13789 invalids++
13790 }
13791 case "addCommentAndReopen":
13792 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13793 return ec._Mutation_addCommentAndReopen(ctx, field)
13794 }
13795
13796 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, innerFunc)
13797
13798 if out.Values[i] == graphql.Null {
13799 invalids++
13800 }
13801 case "editComment":
13802 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13803 return ec._Mutation_editComment(ctx, field)
13804 }
13805
13806 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, innerFunc)
13807
13808 if out.Values[i] == graphql.Null {
13809 invalids++
13810 }
13811 case "changeLabels":
13812 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13813 return ec._Mutation_changeLabels(ctx, field)
13814 }
13815
13816 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, innerFunc)
13817
13818 if out.Values[i] == graphql.Null {
13819 invalids++
13820 }
13821 case "openBug":
13822 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13823 return ec._Mutation_openBug(ctx, field)
13824 }
13825
13826 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, innerFunc)
13827
13828 if out.Values[i] == graphql.Null {
13829 invalids++
13830 }
13831 case "closeBug":
13832 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13833 return ec._Mutation_closeBug(ctx, field)
13834 }
13835
13836 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, innerFunc)
13837
13838 if out.Values[i] == graphql.Null {
13839 invalids++
13840 }
13841 case "setTitle":
13842 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13843 return ec._Mutation_setTitle(ctx, field)
13844 }
13845
13846 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, innerFunc)
13847
13848 if out.Values[i] == graphql.Null {
13849 invalids++
13850 }
13851 default:
13852 panic("unknown field " + strconv.Quote(field.Name))
13853 }
13854 }
13855 out.Dispatch()
13856 if invalids > 0 {
13857 return graphql.Null
13858 }
13859 return out
13860}
13861
13862var newBugPayloadImplementors = []string{"NewBugPayload"}
13863
13864func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
13865 fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
13866 out := graphql.NewFieldSet(fields)
13867 var invalids uint32
13868 for i, field := range fields {
13869 switch field.Name {
13870 case "__typename":
13871 out.Values[i] = graphql.MarshalString("NewBugPayload")
13872 case "clientMutationId":
13873 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13874 return ec._NewBugPayload_clientMutationId(ctx, field, obj)
13875 }
13876
13877 out.Values[i] = innerFunc(ctx)
13878
13879 case "bug":
13880 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13881 return ec._NewBugPayload_bug(ctx, field, obj)
13882 }
13883
13884 out.Values[i] = innerFunc(ctx)
13885
13886 if out.Values[i] == graphql.Null {
13887 invalids++
13888 }
13889 case "operation":
13890 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13891 return ec._NewBugPayload_operation(ctx, field, obj)
13892 }
13893
13894 out.Values[i] = innerFunc(ctx)
13895
13896 if out.Values[i] == graphql.Null {
13897 invalids++
13898 }
13899 default:
13900 panic("unknown field " + strconv.Quote(field.Name))
13901 }
13902 }
13903 out.Dispatch()
13904 if invalids > 0 {
13905 return graphql.Null
13906 }
13907 return out
13908}
13909
13910var openBugPayloadImplementors = []string{"OpenBugPayload"}
13911
13912func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
13913 fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
13914 out := graphql.NewFieldSet(fields)
13915 var invalids uint32
13916 for i, field := range fields {
13917 switch field.Name {
13918 case "__typename":
13919 out.Values[i] = graphql.MarshalString("OpenBugPayload")
13920 case "clientMutationId":
13921 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13922 return ec._OpenBugPayload_clientMutationId(ctx, field, obj)
13923 }
13924
13925 out.Values[i] = innerFunc(ctx)
13926
13927 case "bug":
13928 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13929 return ec._OpenBugPayload_bug(ctx, field, obj)
13930 }
13931
13932 out.Values[i] = innerFunc(ctx)
13933
13934 if out.Values[i] == graphql.Null {
13935 invalids++
13936 }
13937 case "operation":
13938 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13939 return ec._OpenBugPayload_operation(ctx, field, obj)
13940 }
13941
13942 out.Values[i] = innerFunc(ctx)
13943
13944 if out.Values[i] == graphql.Null {
13945 invalids++
13946 }
13947 default:
13948 panic("unknown field " + strconv.Quote(field.Name))
13949 }
13950 }
13951 out.Dispatch()
13952 if invalids > 0 {
13953 return graphql.Null
13954 }
13955 return out
13956}
13957
13958var operationConnectionImplementors = []string{"OperationConnection"}
13959
13960func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
13961 fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
13962 out := graphql.NewFieldSet(fields)
13963 var invalids uint32
13964 for i, field := range fields {
13965 switch field.Name {
13966 case "__typename":
13967 out.Values[i] = graphql.MarshalString("OperationConnection")
13968 case "edges":
13969 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13970 return ec._OperationConnection_edges(ctx, field, obj)
13971 }
13972
13973 out.Values[i] = innerFunc(ctx)
13974
13975 if out.Values[i] == graphql.Null {
13976 invalids++
13977 }
13978 case "nodes":
13979 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13980 return ec._OperationConnection_nodes(ctx, field, obj)
13981 }
13982
13983 out.Values[i] = innerFunc(ctx)
13984
13985 if out.Values[i] == graphql.Null {
13986 invalids++
13987 }
13988 case "pageInfo":
13989 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
13990 return ec._OperationConnection_pageInfo(ctx, field, obj)
13991 }
13992
13993 out.Values[i] = innerFunc(ctx)
13994
13995 if out.Values[i] == graphql.Null {
13996 invalids++
13997 }
13998 case "totalCount":
13999 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14000 return ec._OperationConnection_totalCount(ctx, field, obj)
14001 }
14002
14003 out.Values[i] = innerFunc(ctx)
14004
14005 if out.Values[i] == graphql.Null {
14006 invalids++
14007 }
14008 default:
14009 panic("unknown field " + strconv.Quote(field.Name))
14010 }
14011 }
14012 out.Dispatch()
14013 if invalids > 0 {
14014 return graphql.Null
14015 }
14016 return out
14017}
14018
14019var operationEdgeImplementors = []string{"OperationEdge"}
14020
14021func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
14022 fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
14023 out := graphql.NewFieldSet(fields)
14024 var invalids uint32
14025 for i, field := range fields {
14026 switch field.Name {
14027 case "__typename":
14028 out.Values[i] = graphql.MarshalString("OperationEdge")
14029 case "cursor":
14030 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14031 return ec._OperationEdge_cursor(ctx, field, obj)
14032 }
14033
14034 out.Values[i] = innerFunc(ctx)
14035
14036 if out.Values[i] == graphql.Null {
14037 invalids++
14038 }
14039 case "node":
14040 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14041 return ec._OperationEdge_node(ctx, field, obj)
14042 }
14043
14044 out.Values[i] = innerFunc(ctx)
14045
14046 if out.Values[i] == graphql.Null {
14047 invalids++
14048 }
14049 default:
14050 panic("unknown field " + strconv.Quote(field.Name))
14051 }
14052 }
14053 out.Dispatch()
14054 if invalids > 0 {
14055 return graphql.Null
14056 }
14057 return out
14058}
14059
14060var pageInfoImplementors = []string{"PageInfo"}
14061
14062func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
14063 fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
14064 out := graphql.NewFieldSet(fields)
14065 var invalids uint32
14066 for i, field := range fields {
14067 switch field.Name {
14068 case "__typename":
14069 out.Values[i] = graphql.MarshalString("PageInfo")
14070 case "hasNextPage":
14071 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14072 return ec._PageInfo_hasNextPage(ctx, field, obj)
14073 }
14074
14075 out.Values[i] = innerFunc(ctx)
14076
14077 if out.Values[i] == graphql.Null {
14078 invalids++
14079 }
14080 case "hasPreviousPage":
14081 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14082 return ec._PageInfo_hasPreviousPage(ctx, field, obj)
14083 }
14084
14085 out.Values[i] = innerFunc(ctx)
14086
14087 if out.Values[i] == graphql.Null {
14088 invalids++
14089 }
14090 case "startCursor":
14091 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14092 return ec._PageInfo_startCursor(ctx, field, obj)
14093 }
14094
14095 out.Values[i] = innerFunc(ctx)
14096
14097 if out.Values[i] == graphql.Null {
14098 invalids++
14099 }
14100 case "endCursor":
14101 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14102 return ec._PageInfo_endCursor(ctx, field, obj)
14103 }
14104
14105 out.Values[i] = innerFunc(ctx)
14106
14107 if out.Values[i] == graphql.Null {
14108 invalids++
14109 }
14110 default:
14111 panic("unknown field " + strconv.Quote(field.Name))
14112 }
14113 }
14114 out.Dispatch()
14115 if invalids > 0 {
14116 return graphql.Null
14117 }
14118 return out
14119}
14120
14121var queryImplementors = []string{"Query"}
14122
14123func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
14124 fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
14125 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
14126 Object: "Query",
14127 })
14128
14129 out := graphql.NewFieldSet(fields)
14130 var invalids uint32
14131 for i, field := range fields {
14132 innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
14133 Object: field.Name,
14134 Field: field,
14135 })
14136
14137 switch field.Name {
14138 case "__typename":
14139 out.Values[i] = graphql.MarshalString("Query")
14140 case "repository":
14141 field := field
14142
14143 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14144 defer func() {
14145 if r := recover(); r != nil {
14146 ec.Error(ctx, ec.Recover(ctx, r))
14147 }
14148 }()
14149 res = ec._Query_repository(ctx, field)
14150 return res
14151 }
14152
14153 rrm := func(ctx context.Context) graphql.Marshaler {
14154 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
14155 }
14156
14157 out.Concurrently(i, func() graphql.Marshaler {
14158 return rrm(innerCtx)
14159 })
14160 case "__type":
14161 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14162 return ec._Query___type(ctx, field)
14163 }
14164
14165 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, innerFunc)
14166
14167 case "__schema":
14168 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14169 return ec._Query___schema(ctx, field)
14170 }
14171
14172 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, innerFunc)
14173
14174 default:
14175 panic("unknown field " + strconv.Quote(field.Name))
14176 }
14177 }
14178 out.Dispatch()
14179 if invalids > 0 {
14180 return graphql.Null
14181 }
14182 return out
14183}
14184
14185var repositoryImplementors = []string{"Repository"}
14186
14187func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
14188 fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
14189 out := graphql.NewFieldSet(fields)
14190 var invalids uint32
14191 for i, field := range fields {
14192 switch field.Name {
14193 case "__typename":
14194 out.Values[i] = graphql.MarshalString("Repository")
14195 case "name":
14196 field := field
14197
14198 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14199 defer func() {
14200 if r := recover(); r != nil {
14201 ec.Error(ctx, ec.Recover(ctx, r))
14202 }
14203 }()
14204 res = ec._Repository_name(ctx, field, obj)
14205 return res
14206 }
14207
14208 out.Concurrently(i, func() graphql.Marshaler {
14209 return innerFunc(ctx)
14210
14211 })
14212 case "allBugs":
14213 field := field
14214
14215 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14216 defer func() {
14217 if r := recover(); r != nil {
14218 ec.Error(ctx, ec.Recover(ctx, r))
14219 }
14220 }()
14221 res = ec._Repository_allBugs(ctx, field, obj)
14222 if res == graphql.Null {
14223 atomic.AddUint32(&invalids, 1)
14224 }
14225 return res
14226 }
14227
14228 out.Concurrently(i, func() graphql.Marshaler {
14229 return innerFunc(ctx)
14230
14231 })
14232 case "bug":
14233 field := field
14234
14235 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14236 defer func() {
14237 if r := recover(); r != nil {
14238 ec.Error(ctx, ec.Recover(ctx, r))
14239 }
14240 }()
14241 res = ec._Repository_bug(ctx, field, obj)
14242 return res
14243 }
14244
14245 out.Concurrently(i, func() graphql.Marshaler {
14246 return innerFunc(ctx)
14247
14248 })
14249 case "allIdentities":
14250 field := field
14251
14252 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14253 defer func() {
14254 if r := recover(); r != nil {
14255 ec.Error(ctx, ec.Recover(ctx, r))
14256 }
14257 }()
14258 res = ec._Repository_allIdentities(ctx, field, obj)
14259 if res == graphql.Null {
14260 atomic.AddUint32(&invalids, 1)
14261 }
14262 return res
14263 }
14264
14265 out.Concurrently(i, func() graphql.Marshaler {
14266 return innerFunc(ctx)
14267
14268 })
14269 case "identity":
14270 field := field
14271
14272 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14273 defer func() {
14274 if r := recover(); r != nil {
14275 ec.Error(ctx, ec.Recover(ctx, r))
14276 }
14277 }()
14278 res = ec._Repository_identity(ctx, field, obj)
14279 return res
14280 }
14281
14282 out.Concurrently(i, func() graphql.Marshaler {
14283 return innerFunc(ctx)
14284
14285 })
14286 case "userIdentity":
14287 field := field
14288
14289 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14290 defer func() {
14291 if r := recover(); r != nil {
14292 ec.Error(ctx, ec.Recover(ctx, r))
14293 }
14294 }()
14295 res = ec._Repository_userIdentity(ctx, field, obj)
14296 return res
14297 }
14298
14299 out.Concurrently(i, func() graphql.Marshaler {
14300 return innerFunc(ctx)
14301
14302 })
14303 case "validLabels":
14304 field := field
14305
14306 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14307 defer func() {
14308 if r := recover(); r != nil {
14309 ec.Error(ctx, ec.Recover(ctx, r))
14310 }
14311 }()
14312 res = ec._Repository_validLabels(ctx, field, obj)
14313 if res == graphql.Null {
14314 atomic.AddUint32(&invalids, 1)
14315 }
14316 return res
14317 }
14318
14319 out.Concurrently(i, func() graphql.Marshaler {
14320 return innerFunc(ctx)
14321
14322 })
14323 default:
14324 panic("unknown field " + strconv.Quote(field.Name))
14325 }
14326 }
14327 out.Dispatch()
14328 if invalids > 0 {
14329 return graphql.Null
14330 }
14331 return out
14332}
14333
14334var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
14335
14336func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
14337 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
14338 out := graphql.NewFieldSet(fields)
14339 var invalids uint32
14340 for i, field := range fields {
14341 switch field.Name {
14342 case "__typename":
14343 out.Values[i] = graphql.MarshalString("SetStatusOperation")
14344 case "id":
14345 field := field
14346
14347 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14348 defer func() {
14349 if r := recover(); r != nil {
14350 ec.Error(ctx, ec.Recover(ctx, r))
14351 }
14352 }()
14353 res = ec._SetStatusOperation_id(ctx, field, obj)
14354 if res == graphql.Null {
14355 atomic.AddUint32(&invalids, 1)
14356 }
14357 return res
14358 }
14359
14360 out.Concurrently(i, func() graphql.Marshaler {
14361 return innerFunc(ctx)
14362
14363 })
14364 case "author":
14365 field := field
14366
14367 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14368 defer func() {
14369 if r := recover(); r != nil {
14370 ec.Error(ctx, ec.Recover(ctx, r))
14371 }
14372 }()
14373 res = ec._SetStatusOperation_author(ctx, field, obj)
14374 if res == graphql.Null {
14375 atomic.AddUint32(&invalids, 1)
14376 }
14377 return res
14378 }
14379
14380 out.Concurrently(i, func() graphql.Marshaler {
14381 return innerFunc(ctx)
14382
14383 })
14384 case "date":
14385 field := field
14386
14387 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14388 defer func() {
14389 if r := recover(); r != nil {
14390 ec.Error(ctx, ec.Recover(ctx, r))
14391 }
14392 }()
14393 res = ec._SetStatusOperation_date(ctx, field, obj)
14394 if res == graphql.Null {
14395 atomic.AddUint32(&invalids, 1)
14396 }
14397 return res
14398 }
14399
14400 out.Concurrently(i, func() graphql.Marshaler {
14401 return innerFunc(ctx)
14402
14403 })
14404 case "status":
14405 field := field
14406
14407 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14408 defer func() {
14409 if r := recover(); r != nil {
14410 ec.Error(ctx, ec.Recover(ctx, r))
14411 }
14412 }()
14413 res = ec._SetStatusOperation_status(ctx, field, obj)
14414 if res == graphql.Null {
14415 atomic.AddUint32(&invalids, 1)
14416 }
14417 return res
14418 }
14419
14420 out.Concurrently(i, func() graphql.Marshaler {
14421 return innerFunc(ctx)
14422
14423 })
14424 default:
14425 panic("unknown field " + strconv.Quote(field.Name))
14426 }
14427 }
14428 out.Dispatch()
14429 if invalids > 0 {
14430 return graphql.Null
14431 }
14432 return out
14433}
14434
14435var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
14436
14437func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
14438 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
14439 out := graphql.NewFieldSet(fields)
14440 var invalids uint32
14441 for i, field := range fields {
14442 switch field.Name {
14443 case "__typename":
14444 out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
14445 case "id":
14446 field := field
14447
14448 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14449 defer func() {
14450 if r := recover(); r != nil {
14451 ec.Error(ctx, ec.Recover(ctx, r))
14452 }
14453 }()
14454 res = ec._SetStatusTimelineItem_id(ctx, field, obj)
14455 if res == graphql.Null {
14456 atomic.AddUint32(&invalids, 1)
14457 }
14458 return res
14459 }
14460
14461 out.Concurrently(i, func() graphql.Marshaler {
14462 return innerFunc(ctx)
14463
14464 })
14465 case "author":
14466 field := field
14467
14468 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14469 defer func() {
14470 if r := recover(); r != nil {
14471 ec.Error(ctx, ec.Recover(ctx, r))
14472 }
14473 }()
14474 res = ec._SetStatusTimelineItem_author(ctx, field, obj)
14475 if res == graphql.Null {
14476 atomic.AddUint32(&invalids, 1)
14477 }
14478 return res
14479 }
14480
14481 out.Concurrently(i, func() graphql.Marshaler {
14482 return innerFunc(ctx)
14483
14484 })
14485 case "date":
14486 field := field
14487
14488 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14489 defer func() {
14490 if r := recover(); r != nil {
14491 ec.Error(ctx, ec.Recover(ctx, r))
14492 }
14493 }()
14494 res = ec._SetStatusTimelineItem_date(ctx, field, obj)
14495 if res == graphql.Null {
14496 atomic.AddUint32(&invalids, 1)
14497 }
14498 return res
14499 }
14500
14501 out.Concurrently(i, func() graphql.Marshaler {
14502 return innerFunc(ctx)
14503
14504 })
14505 case "status":
14506 field := field
14507
14508 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14509 defer func() {
14510 if r := recover(); r != nil {
14511 ec.Error(ctx, ec.Recover(ctx, r))
14512 }
14513 }()
14514 res = ec._SetStatusTimelineItem_status(ctx, field, obj)
14515 if res == graphql.Null {
14516 atomic.AddUint32(&invalids, 1)
14517 }
14518 return res
14519 }
14520
14521 out.Concurrently(i, func() graphql.Marshaler {
14522 return innerFunc(ctx)
14523
14524 })
14525 default:
14526 panic("unknown field " + strconv.Quote(field.Name))
14527 }
14528 }
14529 out.Dispatch()
14530 if invalids > 0 {
14531 return graphql.Null
14532 }
14533 return out
14534}
14535
14536var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
14537
14538func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
14539 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
14540 out := graphql.NewFieldSet(fields)
14541 var invalids uint32
14542 for i, field := range fields {
14543 switch field.Name {
14544 case "__typename":
14545 out.Values[i] = graphql.MarshalString("SetTitleOperation")
14546 case "id":
14547 field := field
14548
14549 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14550 defer func() {
14551 if r := recover(); r != nil {
14552 ec.Error(ctx, ec.Recover(ctx, r))
14553 }
14554 }()
14555 res = ec._SetTitleOperation_id(ctx, field, obj)
14556 if res == graphql.Null {
14557 atomic.AddUint32(&invalids, 1)
14558 }
14559 return res
14560 }
14561
14562 out.Concurrently(i, func() graphql.Marshaler {
14563 return innerFunc(ctx)
14564
14565 })
14566 case "author":
14567 field := field
14568
14569 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14570 defer func() {
14571 if r := recover(); r != nil {
14572 ec.Error(ctx, ec.Recover(ctx, r))
14573 }
14574 }()
14575 res = ec._SetTitleOperation_author(ctx, field, obj)
14576 if res == graphql.Null {
14577 atomic.AddUint32(&invalids, 1)
14578 }
14579 return res
14580 }
14581
14582 out.Concurrently(i, func() graphql.Marshaler {
14583 return innerFunc(ctx)
14584
14585 })
14586 case "date":
14587 field := field
14588
14589 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14590 defer func() {
14591 if r := recover(); r != nil {
14592 ec.Error(ctx, ec.Recover(ctx, r))
14593 }
14594 }()
14595 res = ec._SetTitleOperation_date(ctx, field, obj)
14596 if res == graphql.Null {
14597 atomic.AddUint32(&invalids, 1)
14598 }
14599 return res
14600 }
14601
14602 out.Concurrently(i, func() graphql.Marshaler {
14603 return innerFunc(ctx)
14604
14605 })
14606 case "title":
14607 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14608 return ec._SetTitleOperation_title(ctx, field, obj)
14609 }
14610
14611 out.Values[i] = innerFunc(ctx)
14612
14613 if out.Values[i] == graphql.Null {
14614 atomic.AddUint32(&invalids, 1)
14615 }
14616 case "was":
14617 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14618 return ec._SetTitleOperation_was(ctx, field, obj)
14619 }
14620
14621 out.Values[i] = innerFunc(ctx)
14622
14623 if out.Values[i] == graphql.Null {
14624 atomic.AddUint32(&invalids, 1)
14625 }
14626 default:
14627 panic("unknown field " + strconv.Quote(field.Name))
14628 }
14629 }
14630 out.Dispatch()
14631 if invalids > 0 {
14632 return graphql.Null
14633 }
14634 return out
14635}
14636
14637var setTitlePayloadImplementors = []string{"SetTitlePayload"}
14638
14639func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
14640 fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
14641 out := graphql.NewFieldSet(fields)
14642 var invalids uint32
14643 for i, field := range fields {
14644 switch field.Name {
14645 case "__typename":
14646 out.Values[i] = graphql.MarshalString("SetTitlePayload")
14647 case "clientMutationId":
14648 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14649 return ec._SetTitlePayload_clientMutationId(ctx, field, obj)
14650 }
14651
14652 out.Values[i] = innerFunc(ctx)
14653
14654 case "bug":
14655 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14656 return ec._SetTitlePayload_bug(ctx, field, obj)
14657 }
14658
14659 out.Values[i] = innerFunc(ctx)
14660
14661 if out.Values[i] == graphql.Null {
14662 invalids++
14663 }
14664 case "operation":
14665 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14666 return ec._SetTitlePayload_operation(ctx, field, obj)
14667 }
14668
14669 out.Values[i] = innerFunc(ctx)
14670
14671 if out.Values[i] == graphql.Null {
14672 invalids++
14673 }
14674 default:
14675 panic("unknown field " + strconv.Quote(field.Name))
14676 }
14677 }
14678 out.Dispatch()
14679 if invalids > 0 {
14680 return graphql.Null
14681 }
14682 return out
14683}
14684
14685var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
14686
14687func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
14688 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
14689 out := graphql.NewFieldSet(fields)
14690 var invalids uint32
14691 for i, field := range fields {
14692 switch field.Name {
14693 case "__typename":
14694 out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
14695 case "id":
14696 field := field
14697
14698 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14699 defer func() {
14700 if r := recover(); r != nil {
14701 ec.Error(ctx, ec.Recover(ctx, r))
14702 }
14703 }()
14704 res = ec._SetTitleTimelineItem_id(ctx, field, obj)
14705 if res == graphql.Null {
14706 atomic.AddUint32(&invalids, 1)
14707 }
14708 return res
14709 }
14710
14711 out.Concurrently(i, func() graphql.Marshaler {
14712 return innerFunc(ctx)
14713
14714 })
14715 case "author":
14716 field := field
14717
14718 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14719 defer func() {
14720 if r := recover(); r != nil {
14721 ec.Error(ctx, ec.Recover(ctx, r))
14722 }
14723 }()
14724 res = ec._SetTitleTimelineItem_author(ctx, field, obj)
14725 if res == graphql.Null {
14726 atomic.AddUint32(&invalids, 1)
14727 }
14728 return res
14729 }
14730
14731 out.Concurrently(i, func() graphql.Marshaler {
14732 return innerFunc(ctx)
14733
14734 })
14735 case "date":
14736 field := field
14737
14738 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14739 defer func() {
14740 if r := recover(); r != nil {
14741 ec.Error(ctx, ec.Recover(ctx, r))
14742 }
14743 }()
14744 res = ec._SetTitleTimelineItem_date(ctx, field, obj)
14745 if res == graphql.Null {
14746 atomic.AddUint32(&invalids, 1)
14747 }
14748 return res
14749 }
14750
14751 out.Concurrently(i, func() graphql.Marshaler {
14752 return innerFunc(ctx)
14753
14754 })
14755 case "title":
14756 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14757 return ec._SetTitleTimelineItem_title(ctx, field, obj)
14758 }
14759
14760 out.Values[i] = innerFunc(ctx)
14761
14762 if out.Values[i] == graphql.Null {
14763 atomic.AddUint32(&invalids, 1)
14764 }
14765 case "was":
14766 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14767 return ec._SetTitleTimelineItem_was(ctx, field, obj)
14768 }
14769
14770 out.Values[i] = innerFunc(ctx)
14771
14772 if out.Values[i] == graphql.Null {
14773 atomic.AddUint32(&invalids, 1)
14774 }
14775 default:
14776 panic("unknown field " + strconv.Quote(field.Name))
14777 }
14778 }
14779 out.Dispatch()
14780 if invalids > 0 {
14781 return graphql.Null
14782 }
14783 return out
14784}
14785
14786var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
14787
14788func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
14789 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
14790 out := graphql.NewFieldSet(fields)
14791 var invalids uint32
14792 for i, field := range fields {
14793 switch field.Name {
14794 case "__typename":
14795 out.Values[i] = graphql.MarshalString("TimelineItemConnection")
14796 case "edges":
14797 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14798 return ec._TimelineItemConnection_edges(ctx, field, obj)
14799 }
14800
14801 out.Values[i] = innerFunc(ctx)
14802
14803 if out.Values[i] == graphql.Null {
14804 invalids++
14805 }
14806 case "nodes":
14807 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14808 return ec._TimelineItemConnection_nodes(ctx, field, obj)
14809 }
14810
14811 out.Values[i] = innerFunc(ctx)
14812
14813 if out.Values[i] == graphql.Null {
14814 invalids++
14815 }
14816 case "pageInfo":
14817 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14818 return ec._TimelineItemConnection_pageInfo(ctx, field, obj)
14819 }
14820
14821 out.Values[i] = innerFunc(ctx)
14822
14823 if out.Values[i] == graphql.Null {
14824 invalids++
14825 }
14826 case "totalCount":
14827 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14828 return ec._TimelineItemConnection_totalCount(ctx, field, obj)
14829 }
14830
14831 out.Values[i] = innerFunc(ctx)
14832
14833 if out.Values[i] == graphql.Null {
14834 invalids++
14835 }
14836 default:
14837 panic("unknown field " + strconv.Quote(field.Name))
14838 }
14839 }
14840 out.Dispatch()
14841 if invalids > 0 {
14842 return graphql.Null
14843 }
14844 return out
14845}
14846
14847var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
14848
14849func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
14850 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
14851 out := graphql.NewFieldSet(fields)
14852 var invalids uint32
14853 for i, field := range fields {
14854 switch field.Name {
14855 case "__typename":
14856 out.Values[i] = graphql.MarshalString("TimelineItemEdge")
14857 case "cursor":
14858 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14859 return ec._TimelineItemEdge_cursor(ctx, field, obj)
14860 }
14861
14862 out.Values[i] = innerFunc(ctx)
14863
14864 if out.Values[i] == graphql.Null {
14865 invalids++
14866 }
14867 case "node":
14868 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14869 return ec._TimelineItemEdge_node(ctx, field, obj)
14870 }
14871
14872 out.Values[i] = innerFunc(ctx)
14873
14874 if out.Values[i] == graphql.Null {
14875 invalids++
14876 }
14877 default:
14878 panic("unknown field " + strconv.Quote(field.Name))
14879 }
14880 }
14881 out.Dispatch()
14882 if invalids > 0 {
14883 return graphql.Null
14884 }
14885 return out
14886}
14887
14888var __DirectiveImplementors = []string{"__Directive"}
14889
14890func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
14891 fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
14892 out := graphql.NewFieldSet(fields)
14893 var invalids uint32
14894 for i, field := range fields {
14895 switch field.Name {
14896 case "__typename":
14897 out.Values[i] = graphql.MarshalString("__Directive")
14898 case "name":
14899 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14900 return ec.___Directive_name(ctx, field, obj)
14901 }
14902
14903 out.Values[i] = innerFunc(ctx)
14904
14905 if out.Values[i] == graphql.Null {
14906 invalids++
14907 }
14908 case "description":
14909 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14910 return ec.___Directive_description(ctx, field, obj)
14911 }
14912
14913 out.Values[i] = innerFunc(ctx)
14914
14915 case "locations":
14916 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14917 return ec.___Directive_locations(ctx, field, obj)
14918 }
14919
14920 out.Values[i] = innerFunc(ctx)
14921
14922 if out.Values[i] == graphql.Null {
14923 invalids++
14924 }
14925 case "args":
14926 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14927 return ec.___Directive_args(ctx, field, obj)
14928 }
14929
14930 out.Values[i] = innerFunc(ctx)
14931
14932 if out.Values[i] == graphql.Null {
14933 invalids++
14934 }
14935 case "isRepeatable":
14936 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14937 return ec.___Directive_isRepeatable(ctx, field, obj)
14938 }
14939
14940 out.Values[i] = innerFunc(ctx)
14941
14942 if out.Values[i] == graphql.Null {
14943 invalids++
14944 }
14945 default:
14946 panic("unknown field " + strconv.Quote(field.Name))
14947 }
14948 }
14949 out.Dispatch()
14950 if invalids > 0 {
14951 return graphql.Null
14952 }
14953 return out
14954}
14955
14956var __EnumValueImplementors = []string{"__EnumValue"}
14957
14958func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
14959 fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
14960 out := graphql.NewFieldSet(fields)
14961 var invalids uint32
14962 for i, field := range fields {
14963 switch field.Name {
14964 case "__typename":
14965 out.Values[i] = graphql.MarshalString("__EnumValue")
14966 case "name":
14967 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14968 return ec.___EnumValue_name(ctx, field, obj)
14969 }
14970
14971 out.Values[i] = innerFunc(ctx)
14972
14973 if out.Values[i] == graphql.Null {
14974 invalids++
14975 }
14976 case "description":
14977 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14978 return ec.___EnumValue_description(ctx, field, obj)
14979 }
14980
14981 out.Values[i] = innerFunc(ctx)
14982
14983 case "isDeprecated":
14984 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14985 return ec.___EnumValue_isDeprecated(ctx, field, obj)
14986 }
14987
14988 out.Values[i] = innerFunc(ctx)
14989
14990 if out.Values[i] == graphql.Null {
14991 invalids++
14992 }
14993 case "deprecationReason":
14994 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
14995 return ec.___EnumValue_deprecationReason(ctx, field, obj)
14996 }
14997
14998 out.Values[i] = innerFunc(ctx)
14999
15000 default:
15001 panic("unknown field " + strconv.Quote(field.Name))
15002 }
15003 }
15004 out.Dispatch()
15005 if invalids > 0 {
15006 return graphql.Null
15007 }
15008 return out
15009}
15010
15011var __FieldImplementors = []string{"__Field"}
15012
15013func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
15014 fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
15015 out := graphql.NewFieldSet(fields)
15016 var invalids uint32
15017 for i, field := range fields {
15018 switch field.Name {
15019 case "__typename":
15020 out.Values[i] = graphql.MarshalString("__Field")
15021 case "name":
15022 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15023 return ec.___Field_name(ctx, field, obj)
15024 }
15025
15026 out.Values[i] = innerFunc(ctx)
15027
15028 if out.Values[i] == graphql.Null {
15029 invalids++
15030 }
15031 case "description":
15032 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15033 return ec.___Field_description(ctx, field, obj)
15034 }
15035
15036 out.Values[i] = innerFunc(ctx)
15037
15038 case "args":
15039 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15040 return ec.___Field_args(ctx, field, obj)
15041 }
15042
15043 out.Values[i] = innerFunc(ctx)
15044
15045 if out.Values[i] == graphql.Null {
15046 invalids++
15047 }
15048 case "type":
15049 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15050 return ec.___Field_type(ctx, field, obj)
15051 }
15052
15053 out.Values[i] = innerFunc(ctx)
15054
15055 if out.Values[i] == graphql.Null {
15056 invalids++
15057 }
15058 case "isDeprecated":
15059 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15060 return ec.___Field_isDeprecated(ctx, field, obj)
15061 }
15062
15063 out.Values[i] = innerFunc(ctx)
15064
15065 if out.Values[i] == graphql.Null {
15066 invalids++
15067 }
15068 case "deprecationReason":
15069 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15070 return ec.___Field_deprecationReason(ctx, field, obj)
15071 }
15072
15073 out.Values[i] = innerFunc(ctx)
15074
15075 default:
15076 panic("unknown field " + strconv.Quote(field.Name))
15077 }
15078 }
15079 out.Dispatch()
15080 if invalids > 0 {
15081 return graphql.Null
15082 }
15083 return out
15084}
15085
15086var __InputValueImplementors = []string{"__InputValue"}
15087
15088func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
15089 fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
15090 out := graphql.NewFieldSet(fields)
15091 var invalids uint32
15092 for i, field := range fields {
15093 switch field.Name {
15094 case "__typename":
15095 out.Values[i] = graphql.MarshalString("__InputValue")
15096 case "name":
15097 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15098 return ec.___InputValue_name(ctx, field, obj)
15099 }
15100
15101 out.Values[i] = innerFunc(ctx)
15102
15103 if out.Values[i] == graphql.Null {
15104 invalids++
15105 }
15106 case "description":
15107 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15108 return ec.___InputValue_description(ctx, field, obj)
15109 }
15110
15111 out.Values[i] = innerFunc(ctx)
15112
15113 case "type":
15114 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15115 return ec.___InputValue_type(ctx, field, obj)
15116 }
15117
15118 out.Values[i] = innerFunc(ctx)
15119
15120 if out.Values[i] == graphql.Null {
15121 invalids++
15122 }
15123 case "defaultValue":
15124 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15125 return ec.___InputValue_defaultValue(ctx, field, obj)
15126 }
15127
15128 out.Values[i] = innerFunc(ctx)
15129
15130 default:
15131 panic("unknown field " + strconv.Quote(field.Name))
15132 }
15133 }
15134 out.Dispatch()
15135 if invalids > 0 {
15136 return graphql.Null
15137 }
15138 return out
15139}
15140
15141var __SchemaImplementors = []string{"__Schema"}
15142
15143func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
15144 fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
15145 out := graphql.NewFieldSet(fields)
15146 var invalids uint32
15147 for i, field := range fields {
15148 switch field.Name {
15149 case "__typename":
15150 out.Values[i] = graphql.MarshalString("__Schema")
15151 case "types":
15152 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15153 return ec.___Schema_types(ctx, field, obj)
15154 }
15155
15156 out.Values[i] = innerFunc(ctx)
15157
15158 if out.Values[i] == graphql.Null {
15159 invalids++
15160 }
15161 case "queryType":
15162 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15163 return ec.___Schema_queryType(ctx, field, obj)
15164 }
15165
15166 out.Values[i] = innerFunc(ctx)
15167
15168 if out.Values[i] == graphql.Null {
15169 invalids++
15170 }
15171 case "mutationType":
15172 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15173 return ec.___Schema_mutationType(ctx, field, obj)
15174 }
15175
15176 out.Values[i] = innerFunc(ctx)
15177
15178 case "subscriptionType":
15179 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15180 return ec.___Schema_subscriptionType(ctx, field, obj)
15181 }
15182
15183 out.Values[i] = innerFunc(ctx)
15184
15185 case "directives":
15186 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15187 return ec.___Schema_directives(ctx, field, obj)
15188 }
15189
15190 out.Values[i] = innerFunc(ctx)
15191
15192 if out.Values[i] == graphql.Null {
15193 invalids++
15194 }
15195 default:
15196 panic("unknown field " + strconv.Quote(field.Name))
15197 }
15198 }
15199 out.Dispatch()
15200 if invalids > 0 {
15201 return graphql.Null
15202 }
15203 return out
15204}
15205
15206var __TypeImplementors = []string{"__Type"}
15207
15208func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
15209 fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
15210 out := graphql.NewFieldSet(fields)
15211 var invalids uint32
15212 for i, field := range fields {
15213 switch field.Name {
15214 case "__typename":
15215 out.Values[i] = graphql.MarshalString("__Type")
15216 case "kind":
15217 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15218 return ec.___Type_kind(ctx, field, obj)
15219 }
15220
15221 out.Values[i] = innerFunc(ctx)
15222
15223 if out.Values[i] == graphql.Null {
15224 invalids++
15225 }
15226 case "name":
15227 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15228 return ec.___Type_name(ctx, field, obj)
15229 }
15230
15231 out.Values[i] = innerFunc(ctx)
15232
15233 case "description":
15234 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15235 return ec.___Type_description(ctx, field, obj)
15236 }
15237
15238 out.Values[i] = innerFunc(ctx)
15239
15240 case "fields":
15241 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15242 return ec.___Type_fields(ctx, field, obj)
15243 }
15244
15245 out.Values[i] = innerFunc(ctx)
15246
15247 case "interfaces":
15248 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15249 return ec.___Type_interfaces(ctx, field, obj)
15250 }
15251
15252 out.Values[i] = innerFunc(ctx)
15253
15254 case "possibleTypes":
15255 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15256 return ec.___Type_possibleTypes(ctx, field, obj)
15257 }
15258
15259 out.Values[i] = innerFunc(ctx)
15260
15261 case "enumValues":
15262 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15263 return ec.___Type_enumValues(ctx, field, obj)
15264 }
15265
15266 out.Values[i] = innerFunc(ctx)
15267
15268 case "inputFields":
15269 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15270 return ec.___Type_inputFields(ctx, field, obj)
15271 }
15272
15273 out.Values[i] = innerFunc(ctx)
15274
15275 case "ofType":
15276 innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
15277 return ec.___Type_ofType(ctx, field, obj)
15278 }
15279
15280 out.Values[i] = innerFunc(ctx)
15281
15282 default:
15283 panic("unknown field " + strconv.Quote(field.Name))
15284 }
15285 }
15286 out.Dispatch()
15287 if invalids > 0 {
15288 return graphql.Null
15289 }
15290 return out
15291}
15292
15293// endregion **************************** object.gotpl ****************************
15294
15295// region ***************************** type.gotpl *****************************
15296
15297func (ec *executionContext) unmarshalNAddCommentAndCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugInput(ctx context.Context, v interface{}) (models.AddCommentAndCloseBugInput, error) {
15298 res, err := ec.unmarshalInputAddCommentAndCloseBugInput(ctx, v)
15299 return res, graphql.ErrorOnPath(ctx, err)
15300}
15301
15302func (ec *executionContext) marshalNAddCommentAndCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentAndCloseBugPayload) graphql.Marshaler {
15303 return ec._AddCommentAndCloseBugPayload(ctx, sel, &v)
15304}
15305
15306func (ec *executionContext) marshalNAddCommentAndCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentAndCloseBugPayload) graphql.Marshaler {
15307 if v == nil {
15308 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15309 ec.Errorf(ctx, "must not be null")
15310 }
15311 return graphql.Null
15312 }
15313 return ec._AddCommentAndCloseBugPayload(ctx, sel, v)
15314}
15315
15316func (ec *executionContext) unmarshalNAddCommentAndReopenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugInput(ctx context.Context, v interface{}) (models.AddCommentAndReopenBugInput, error) {
15317 res, err := ec.unmarshalInputAddCommentAndReopenBugInput(ctx, v)
15318 return res, graphql.ErrorOnPath(ctx, err)
15319}
15320
15321func (ec *executionContext) marshalNAddCommentAndReopenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentAndReopenBugPayload) graphql.Marshaler {
15322 return ec._AddCommentAndReopenBugPayload(ctx, sel, &v)
15323}
15324
15325func (ec *executionContext) marshalNAddCommentAndReopenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentAndReopenBugPayload) graphql.Marshaler {
15326 if v == nil {
15327 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15328 ec.Errorf(ctx, "must not be null")
15329 }
15330 return graphql.Null
15331 }
15332 return ec._AddCommentAndReopenBugPayload(ctx, sel, v)
15333}
15334
15335func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
15336 res, err := ec.unmarshalInputAddCommentInput(ctx, v)
15337 return res, graphql.ErrorOnPath(ctx, err)
15338}
15339
15340func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
15341 if v == nil {
15342 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15343 ec.Errorf(ctx, "must not be null")
15344 }
15345 return graphql.Null
15346 }
15347 return ec._AddCommentOperation(ctx, sel, v)
15348}
15349
15350func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
15351 return ec._AddCommentPayload(ctx, sel, &v)
15352}
15353
15354func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
15355 if v == nil {
15356 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15357 ec.Errorf(ctx, "must not be null")
15358 }
15359 return graphql.Null
15360 }
15361 return ec._AddCommentPayload(ctx, sel, v)
15362}
15363
15364func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
15365 res, err := graphql.UnmarshalBoolean(v)
15366 return res, graphql.ErrorOnPath(ctx, err)
15367}
15368
15369func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
15370 res := graphql.MarshalBoolean(v)
15371 if res == graphql.Null {
15372 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15373 ec.Errorf(ctx, "must not be null")
15374 }
15375 }
15376 return res
15377}
15378
15379func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
15380 if v == nil {
15381 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15382 ec.Errorf(ctx, "must not be null")
15383 }
15384 return graphql.Null
15385 }
15386 return ec._Bug(ctx, sel, v)
15387}
15388
15389func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
15390 ret := make(graphql.Array, len(v))
15391 var wg sync.WaitGroup
15392 isLen1 := len(v) == 1
15393 if !isLen1 {
15394 wg.Add(len(v))
15395 }
15396 for i := range v {
15397 i := i
15398 fc := &graphql.FieldContext{
15399 Index: &i,
15400 Result: &v[i],
15401 }
15402 ctx := graphql.WithFieldContext(ctx, fc)
15403 f := func(i int) {
15404 defer func() {
15405 if r := recover(); r != nil {
15406 ec.Error(ctx, ec.Recover(ctx, r))
15407 ret = nil
15408 }
15409 }()
15410 if !isLen1 {
15411 defer wg.Done()
15412 }
15413 ret[i] = ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
15414 }
15415 if isLen1 {
15416 f(i)
15417 } else {
15418 go f(i)
15419 }
15420
15421 }
15422 wg.Wait()
15423
15424 for _, e := range ret {
15425 if e == graphql.Null {
15426 return graphql.Null
15427 }
15428 }
15429
15430 return ret
15431}
15432
15433func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
15434 return ec._BugConnection(ctx, sel, &v)
15435}
15436
15437func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
15438 if v == nil {
15439 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15440 ec.Errorf(ctx, "must not be null")
15441 }
15442 return graphql.Null
15443 }
15444 return ec._BugConnection(ctx, sel, v)
15445}
15446
15447func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
15448 ret := make(graphql.Array, len(v))
15449 var wg sync.WaitGroup
15450 isLen1 := len(v) == 1
15451 if !isLen1 {
15452 wg.Add(len(v))
15453 }
15454 for i := range v {
15455 i := i
15456 fc := &graphql.FieldContext{
15457 Index: &i,
15458 Result: &v[i],
15459 }
15460 ctx := graphql.WithFieldContext(ctx, fc)
15461 f := func(i int) {
15462 defer func() {
15463 if r := recover(); r != nil {
15464 ec.Error(ctx, ec.Recover(ctx, r))
15465 ret = nil
15466 }
15467 }()
15468 if !isLen1 {
15469 defer wg.Done()
15470 }
15471 ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
15472 }
15473 if isLen1 {
15474 f(i)
15475 } else {
15476 go f(i)
15477 }
15478
15479 }
15480 wg.Wait()
15481
15482 for _, e := range ret {
15483 if e == graphql.Null {
15484 return graphql.Null
15485 }
15486 }
15487
15488 return ret
15489}
15490
15491func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
15492 if v == nil {
15493 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15494 ec.Errorf(ctx, "must not be null")
15495 }
15496 return graphql.Null
15497 }
15498 return ec._BugEdge(ctx, sel, v)
15499}
15500
15501func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
15502 return ec._ChangeLabelPayload(ctx, sel, &v)
15503}
15504
15505func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
15506 if v == nil {
15507 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15508 ec.Errorf(ctx, "must not be null")
15509 }
15510 return graphql.Null
15511 }
15512 return ec._ChangeLabelPayload(ctx, sel, v)
15513}
15514
15515func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
15516 res, err := ec.unmarshalInputCloseBugInput(ctx, v)
15517 return res, graphql.ErrorOnPath(ctx, err)
15518}
15519
15520func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
15521 return ec._CloseBugPayload(ctx, sel, &v)
15522}
15523
15524func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
15525 if v == nil {
15526 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15527 ec.Errorf(ctx, "must not be null")
15528 }
15529 return graphql.Null
15530 }
15531 return ec._CloseBugPayload(ctx, sel, v)
15532}
15533
15534func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
15535 return ec._Color(ctx, sel, &v)
15536}
15537
15538func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
15539 if v == nil {
15540 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15541 ec.Errorf(ctx, "must not be null")
15542 }
15543 return graphql.Null
15544 }
15545 return ec._Color(ctx, sel, v)
15546}
15547
15548func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
15549 ret := make(graphql.Array, len(v))
15550 var wg sync.WaitGroup
15551 isLen1 := len(v) == 1
15552 if !isLen1 {
15553 wg.Add(len(v))
15554 }
15555 for i := range v {
15556 i := i
15557 fc := &graphql.FieldContext{
15558 Index: &i,
15559 Result: &v[i],
15560 }
15561 ctx := graphql.WithFieldContext(ctx, fc)
15562 f := func(i int) {
15563 defer func() {
15564 if r := recover(); r != nil {
15565 ec.Error(ctx, ec.Recover(ctx, r))
15566 ret = nil
15567 }
15568 }()
15569 if !isLen1 {
15570 defer wg.Done()
15571 }
15572 ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
15573 }
15574 if isLen1 {
15575 f(i)
15576 } else {
15577 go f(i)
15578 }
15579
15580 }
15581 wg.Wait()
15582
15583 for _, e := range ret {
15584 if e == graphql.Null {
15585 return graphql.Null
15586 }
15587 }
15588
15589 return ret
15590}
15591
15592func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
15593 if v == nil {
15594 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15595 ec.Errorf(ctx, "must not be null")
15596 }
15597 return graphql.Null
15598 }
15599 return ec._Comment(ctx, sel, v)
15600}
15601
15602func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
15603 return ec._CommentConnection(ctx, sel, &v)
15604}
15605
15606func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
15607 if v == nil {
15608 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15609 ec.Errorf(ctx, "must not be null")
15610 }
15611 return graphql.Null
15612 }
15613 return ec._CommentConnection(ctx, sel, v)
15614}
15615
15616func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
15617 ret := make(graphql.Array, len(v))
15618 var wg sync.WaitGroup
15619 isLen1 := len(v) == 1
15620 if !isLen1 {
15621 wg.Add(len(v))
15622 }
15623 for i := range v {
15624 i := i
15625 fc := &graphql.FieldContext{
15626 Index: &i,
15627 Result: &v[i],
15628 }
15629 ctx := graphql.WithFieldContext(ctx, fc)
15630 f := func(i int) {
15631 defer func() {
15632 if r := recover(); r != nil {
15633 ec.Error(ctx, ec.Recover(ctx, r))
15634 ret = nil
15635 }
15636 }()
15637 if !isLen1 {
15638 defer wg.Done()
15639 }
15640 ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
15641 }
15642 if isLen1 {
15643 f(i)
15644 } else {
15645 go f(i)
15646 }
15647
15648 }
15649 wg.Wait()
15650
15651 for _, e := range ret {
15652 if e == graphql.Null {
15653 return graphql.Null
15654 }
15655 }
15656
15657 return ret
15658}
15659
15660func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
15661 if v == nil {
15662 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15663 ec.Errorf(ctx, "must not be null")
15664 }
15665 return graphql.Null
15666 }
15667 return ec._CommentEdge(ctx, sel, v)
15668}
15669
15670func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
15671 return ec._CommentHistoryStep(ctx, sel, &v)
15672}
15673
15674func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
15675 ret := make(graphql.Array, len(v))
15676 var wg sync.WaitGroup
15677 isLen1 := len(v) == 1
15678 if !isLen1 {
15679 wg.Add(len(v))
15680 }
15681 for i := range v {
15682 i := i
15683 fc := &graphql.FieldContext{
15684 Index: &i,
15685 Result: &v[i],
15686 }
15687 ctx := graphql.WithFieldContext(ctx, fc)
15688 f := func(i int) {
15689 defer func() {
15690 if r := recover(); r != nil {
15691 ec.Error(ctx, ec.Recover(ctx, r))
15692 ret = nil
15693 }
15694 }()
15695 if !isLen1 {
15696 defer wg.Done()
15697 }
15698 ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
15699 }
15700 if isLen1 {
15701 f(i)
15702 } else {
15703 go f(i)
15704 }
15705
15706 }
15707 wg.Wait()
15708
15709 for _, e := range ret {
15710 if e == graphql.Null {
15711 return graphql.Null
15712 }
15713 }
15714
15715 return ret
15716}
15717
15718func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
15719 if v == nil {
15720 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15721 ec.Errorf(ctx, "must not be null")
15722 }
15723 return graphql.Null
15724 }
15725 return ec._CreateOperation(ctx, sel, v)
15726}
15727
15728func (ec *executionContext) unmarshalNEditCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx context.Context, v interface{}) (models.EditCommentInput, error) {
15729 res, err := ec.unmarshalInputEditCommentInput(ctx, v)
15730 return res, graphql.ErrorOnPath(ctx, err)
15731}
15732
15733func (ec *executionContext) marshalNEditCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐEditCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.EditCommentOperation) graphql.Marshaler {
15734 if v == nil {
15735 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15736 ec.Errorf(ctx, "must not be null")
15737 }
15738 return graphql.Null
15739 }
15740 return ec._EditCommentOperation(ctx, sel, v)
15741}
15742
15743func (ec *executionContext) marshalNEditCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.EditCommentPayload) graphql.Marshaler {
15744 return ec._EditCommentPayload(ctx, sel, &v)
15745}
15746
15747func (ec *executionContext) marshalNEditCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.EditCommentPayload) graphql.Marshaler {
15748 if v == nil {
15749 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15750 ec.Errorf(ctx, "must not be null")
15751 }
15752 return graphql.Null
15753 }
15754 return ec._EditCommentPayload(ctx, sel, v)
15755}
15756
15757func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx context.Context, v interface{}) (repository.Hash, error) {
15758 var res repository.Hash
15759 err := res.UnmarshalGQL(v)
15760 return res, graphql.ErrorOnPath(ctx, err)
15761}
15762
15763func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx context.Context, sel ast.SelectionSet, v repository.Hash) graphql.Marshaler {
15764 return v
15765}
15766
15767func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, v interface{}) ([]repository.Hash, error) {
15768 var vSlice []interface{}
15769 if v != nil {
15770 vSlice = graphql.CoerceList(v)
15771 }
15772 var err error
15773 res := make([]repository.Hash, len(vSlice))
15774 for i := range vSlice {
15775 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
15776 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, vSlice[i])
15777 if err != nil {
15778 return nil, err
15779 }
15780 }
15781 return res, nil
15782}
15783
15784func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []repository.Hash) graphql.Marshaler {
15785 ret := make(graphql.Array, len(v))
15786 for i := range v {
15787 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, sel, v[i])
15788 }
15789
15790 for _, e := range ret {
15791 if e == graphql.Null {
15792 return graphql.Null
15793 }
15794 }
15795
15796 return ret
15797}
15798
15799func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
15800 if v == nil {
15801 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15802 ec.Errorf(ctx, "must not be null")
15803 }
15804 return graphql.Null
15805 }
15806 return ec._Identity(ctx, sel, v)
15807}
15808
15809func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.IdentityWrapper) graphql.Marshaler {
15810 ret := make(graphql.Array, len(v))
15811 var wg sync.WaitGroup
15812 isLen1 := len(v) == 1
15813 if !isLen1 {
15814 wg.Add(len(v))
15815 }
15816 for i := range v {
15817 i := i
15818 fc := &graphql.FieldContext{
15819 Index: &i,
15820 Result: &v[i],
15821 }
15822 ctx := graphql.WithFieldContext(ctx, fc)
15823 f := func(i int) {
15824 defer func() {
15825 if r := recover(); r != nil {
15826 ec.Error(ctx, ec.Recover(ctx, r))
15827 ret = nil
15828 }
15829 }()
15830 if !isLen1 {
15831 defer wg.Done()
15832 }
15833 ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, sel, v[i])
15834 }
15835 if isLen1 {
15836 f(i)
15837 } else {
15838 go f(i)
15839 }
15840
15841 }
15842 wg.Wait()
15843
15844 for _, e := range ret {
15845 if e == graphql.Null {
15846 return graphql.Null
15847 }
15848 }
15849
15850 return ret
15851}
15852
15853func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
15854 return ec._IdentityConnection(ctx, sel, &v)
15855}
15856
15857func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
15858 if v == nil {
15859 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15860 ec.Errorf(ctx, "must not be null")
15861 }
15862 return graphql.Null
15863 }
15864 return ec._IdentityConnection(ctx, sel, v)
15865}
15866
15867func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
15868 ret := make(graphql.Array, len(v))
15869 var wg sync.WaitGroup
15870 isLen1 := len(v) == 1
15871 if !isLen1 {
15872 wg.Add(len(v))
15873 }
15874 for i := range v {
15875 i := i
15876 fc := &graphql.FieldContext{
15877 Index: &i,
15878 Result: &v[i],
15879 }
15880 ctx := graphql.WithFieldContext(ctx, fc)
15881 f := func(i int) {
15882 defer func() {
15883 if r := recover(); r != nil {
15884 ec.Error(ctx, ec.Recover(ctx, r))
15885 ret = nil
15886 }
15887 }()
15888 if !isLen1 {
15889 defer wg.Done()
15890 }
15891 ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
15892 }
15893 if isLen1 {
15894 f(i)
15895 } else {
15896 go f(i)
15897 }
15898
15899 }
15900 wg.Wait()
15901
15902 for _, e := range ret {
15903 if e == graphql.Null {
15904 return graphql.Null
15905 }
15906 }
15907
15908 return ret
15909}
15910
15911func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
15912 if v == nil {
15913 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15914 ec.Errorf(ctx, "must not be null")
15915 }
15916 return graphql.Null
15917 }
15918 return ec._IdentityEdge(ctx, sel, v)
15919}
15920
15921func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
15922 res, err := graphql.UnmarshalInt(v)
15923 return res, graphql.ErrorOnPath(ctx, err)
15924}
15925
15926func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
15927 res := graphql.MarshalInt(v)
15928 if res == graphql.Null {
15929 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15930 ec.Errorf(ctx, "must not be null")
15931 }
15932 }
15933 return res
15934}
15935
15936func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
15937 return ec._Label(ctx, sel, &v)
15938}
15939
15940func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
15941 ret := make(graphql.Array, len(v))
15942 var wg sync.WaitGroup
15943 isLen1 := len(v) == 1
15944 if !isLen1 {
15945 wg.Add(len(v))
15946 }
15947 for i := range v {
15948 i := i
15949 fc := &graphql.FieldContext{
15950 Index: &i,
15951 Result: &v[i],
15952 }
15953 ctx := graphql.WithFieldContext(ctx, fc)
15954 f := func(i int) {
15955 defer func() {
15956 if r := recover(); r != nil {
15957 ec.Error(ctx, ec.Recover(ctx, r))
15958 ret = nil
15959 }
15960 }()
15961 if !isLen1 {
15962 defer wg.Done()
15963 }
15964 ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
15965 }
15966 if isLen1 {
15967 f(i)
15968 } else {
15969 go f(i)
15970 }
15971
15972 }
15973 wg.Wait()
15974
15975 for _, e := range ret {
15976 if e == graphql.Null {
15977 return graphql.Null
15978 }
15979 }
15980
15981 return ret
15982}
15983
15984func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
15985 if v == nil {
15986 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15987 ec.Errorf(ctx, "must not be null")
15988 }
15989 return graphql.Null
15990 }
15991 return ec._LabelChangeOperation(ctx, sel, v)
15992}
15993
15994func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
15995 ret := make(graphql.Array, len(v))
15996 var wg sync.WaitGroup
15997 isLen1 := len(v) == 1
15998 if !isLen1 {
15999 wg.Add(len(v))
16000 }
16001 for i := range v {
16002 i := i
16003 fc := &graphql.FieldContext{
16004 Index: &i,
16005 Result: &v[i],
16006 }
16007 ctx := graphql.WithFieldContext(ctx, fc)
16008 f := func(i int) {
16009 defer func() {
16010 if r := recover(); r != nil {
16011 ec.Error(ctx, ec.Recover(ctx, r))
16012 ret = nil
16013 }
16014 }()
16015 if !isLen1 {
16016 defer wg.Done()
16017 }
16018 ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
16019 }
16020 if isLen1 {
16021 f(i)
16022 } else {
16023 go f(i)
16024 }
16025
16026 }
16027 wg.Wait()
16028
16029 return ret
16030}
16031
16032func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
16033 var res models.LabelChangeStatus
16034 err := res.UnmarshalGQL(v)
16035 return res, graphql.ErrorOnPath(ctx, err)
16036}
16037
16038func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
16039 return v
16040}
16041
16042func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
16043 return ec._LabelConnection(ctx, sel, &v)
16044}
16045
16046func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
16047 if v == nil {
16048 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16049 ec.Errorf(ctx, "must not be null")
16050 }
16051 return graphql.Null
16052 }
16053 return ec._LabelConnection(ctx, sel, v)
16054}
16055
16056func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
16057 ret := make(graphql.Array, len(v))
16058 var wg sync.WaitGroup
16059 isLen1 := len(v) == 1
16060 if !isLen1 {
16061 wg.Add(len(v))
16062 }
16063 for i := range v {
16064 i := i
16065 fc := &graphql.FieldContext{
16066 Index: &i,
16067 Result: &v[i],
16068 }
16069 ctx := graphql.WithFieldContext(ctx, fc)
16070 f := func(i int) {
16071 defer func() {
16072 if r := recover(); r != nil {
16073 ec.Error(ctx, ec.Recover(ctx, r))
16074 ret = nil
16075 }
16076 }()
16077 if !isLen1 {
16078 defer wg.Done()
16079 }
16080 ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
16081 }
16082 if isLen1 {
16083 f(i)
16084 } else {
16085 go f(i)
16086 }
16087
16088 }
16089 wg.Wait()
16090
16091 for _, e := range ret {
16092 if e == graphql.Null {
16093 return graphql.Null
16094 }
16095 }
16096
16097 return ret
16098}
16099
16100func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
16101 if v == nil {
16102 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16103 ec.Errorf(ctx, "must not be null")
16104 }
16105 return graphql.Null
16106 }
16107 return ec._LabelEdge(ctx, sel, v)
16108}
16109
16110func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
16111 res, err := ec.unmarshalInputNewBugInput(ctx, v)
16112 return res, graphql.ErrorOnPath(ctx, err)
16113}
16114
16115func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
16116 return ec._NewBugPayload(ctx, sel, &v)
16117}
16118
16119func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
16120 if v == nil {
16121 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16122 ec.Errorf(ctx, "must not be null")
16123 }
16124 return graphql.Null
16125 }
16126 return ec._NewBugPayload(ctx, sel, v)
16127}
16128
16129func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
16130 res, err := ec.unmarshalInputOpenBugInput(ctx, v)
16131 return res, graphql.ErrorOnPath(ctx, err)
16132}
16133
16134func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
16135 return ec._OpenBugPayload(ctx, sel, &v)
16136}
16137
16138func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
16139 if v == nil {
16140 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16141 ec.Errorf(ctx, "must not be null")
16142 }
16143 return graphql.Null
16144 }
16145 return ec._OpenBugPayload(ctx, sel, v)
16146}
16147
16148func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
16149 if v == nil {
16150 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16151 ec.Errorf(ctx, "must not be null")
16152 }
16153 return graphql.Null
16154 }
16155 return ec._Operation(ctx, sel, v)
16156}
16157
16158func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
16159 ret := make(graphql.Array, len(v))
16160 var wg sync.WaitGroup
16161 isLen1 := len(v) == 1
16162 if !isLen1 {
16163 wg.Add(len(v))
16164 }
16165 for i := range v {
16166 i := i
16167 fc := &graphql.FieldContext{
16168 Index: &i,
16169 Result: &v[i],
16170 }
16171 ctx := graphql.WithFieldContext(ctx, fc)
16172 f := func(i int) {
16173 defer func() {
16174 if r := recover(); r != nil {
16175 ec.Error(ctx, ec.Recover(ctx, r))
16176 ret = nil
16177 }
16178 }()
16179 if !isLen1 {
16180 defer wg.Done()
16181 }
16182 ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
16183 }
16184 if isLen1 {
16185 f(i)
16186 } else {
16187 go f(i)
16188 }
16189
16190 }
16191 wg.Wait()
16192
16193 for _, e := range ret {
16194 if e == graphql.Null {
16195 return graphql.Null
16196 }
16197 }
16198
16199 return ret
16200}
16201
16202func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
16203 return ec._OperationConnection(ctx, sel, &v)
16204}
16205
16206func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
16207 if v == nil {
16208 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16209 ec.Errorf(ctx, "must not be null")
16210 }
16211 return graphql.Null
16212 }
16213 return ec._OperationConnection(ctx, sel, v)
16214}
16215
16216func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
16217 ret := make(graphql.Array, len(v))
16218 var wg sync.WaitGroup
16219 isLen1 := len(v) == 1
16220 if !isLen1 {
16221 wg.Add(len(v))
16222 }
16223 for i := range v {
16224 i := i
16225 fc := &graphql.FieldContext{
16226 Index: &i,
16227 Result: &v[i],
16228 }
16229 ctx := graphql.WithFieldContext(ctx, fc)
16230 f := func(i int) {
16231 defer func() {
16232 if r := recover(); r != nil {
16233 ec.Error(ctx, ec.Recover(ctx, r))
16234 ret = nil
16235 }
16236 }()
16237 if !isLen1 {
16238 defer wg.Done()
16239 }
16240 ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
16241 }
16242 if isLen1 {
16243 f(i)
16244 } else {
16245 go f(i)
16246 }
16247
16248 }
16249 wg.Wait()
16250
16251 for _, e := range ret {
16252 if e == graphql.Null {
16253 return graphql.Null
16254 }
16255 }
16256
16257 return ret
16258}
16259
16260func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
16261 if v == nil {
16262 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16263 ec.Errorf(ctx, "must not be null")
16264 }
16265 return graphql.Null
16266 }
16267 return ec._OperationEdge(ctx, sel, v)
16268}
16269
16270func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
16271 if v == nil {
16272 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16273 ec.Errorf(ctx, "must not be null")
16274 }
16275 return graphql.Null
16276 }
16277 return ec._PageInfo(ctx, sel, v)
16278}
16279
16280func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
16281 if v == nil {
16282 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16283 ec.Errorf(ctx, "must not be null")
16284 }
16285 return graphql.Null
16286 }
16287 return ec._SetStatusOperation(ctx, sel, v)
16288}
16289
16290func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
16291 res, err := ec.unmarshalInputSetTitleInput(ctx, v)
16292 return res, graphql.ErrorOnPath(ctx, err)
16293}
16294
16295func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
16296 if v == nil {
16297 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16298 ec.Errorf(ctx, "must not be null")
16299 }
16300 return graphql.Null
16301 }
16302 return ec._SetTitleOperation(ctx, sel, v)
16303}
16304
16305func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
16306 return ec._SetTitlePayload(ctx, sel, &v)
16307}
16308
16309func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
16310 if v == nil {
16311 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16312 ec.Errorf(ctx, "must not be null")
16313 }
16314 return graphql.Null
16315 }
16316 return ec._SetTitlePayload(ctx, sel, v)
16317}
16318
16319func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
16320 var res models.Status
16321 err := res.UnmarshalGQL(v)
16322 return res, graphql.ErrorOnPath(ctx, err)
16323}
16324
16325func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
16326 return v
16327}
16328
16329func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
16330 res, err := graphql.UnmarshalString(v)
16331 return res, graphql.ErrorOnPath(ctx, err)
16332}
16333
16334func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
16335 res := graphql.MarshalString(v)
16336 if res == graphql.Null {
16337 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16338 ec.Errorf(ctx, "must not be null")
16339 }
16340 }
16341 return res
16342}
16343
16344func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
16345 res, err := graphql.UnmarshalTime(v)
16346 return res, graphql.ErrorOnPath(ctx, err)
16347}
16348
16349func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
16350 res := graphql.MarshalTime(v)
16351 if res == graphql.Null {
16352 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16353 ec.Errorf(ctx, "must not be null")
16354 }
16355 }
16356 return res
16357}
16358
16359func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
16360 res, err := graphql.UnmarshalTime(v)
16361 return &res, graphql.ErrorOnPath(ctx, err)
16362}
16363
16364func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
16365 if v == nil {
16366 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16367 ec.Errorf(ctx, "must not be null")
16368 }
16369 return graphql.Null
16370 }
16371 res := graphql.MarshalTime(*v)
16372 if res == graphql.Null {
16373 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16374 ec.Errorf(ctx, "must not be null")
16375 }
16376 }
16377 return res
16378}
16379
16380func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
16381 if v == nil {
16382 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16383 ec.Errorf(ctx, "must not be null")
16384 }
16385 return graphql.Null
16386 }
16387 return ec._TimelineItem(ctx, sel, v)
16388}
16389
16390func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
16391 ret := make(graphql.Array, len(v))
16392 var wg sync.WaitGroup
16393 isLen1 := len(v) == 1
16394 if !isLen1 {
16395 wg.Add(len(v))
16396 }
16397 for i := range v {
16398 i := i
16399 fc := &graphql.FieldContext{
16400 Index: &i,
16401 Result: &v[i],
16402 }
16403 ctx := graphql.WithFieldContext(ctx, fc)
16404 f := func(i int) {
16405 defer func() {
16406 if r := recover(); r != nil {
16407 ec.Error(ctx, ec.Recover(ctx, r))
16408 ret = nil
16409 }
16410 }()
16411 if !isLen1 {
16412 defer wg.Done()
16413 }
16414 ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
16415 }
16416 if isLen1 {
16417 f(i)
16418 } else {
16419 go f(i)
16420 }
16421
16422 }
16423 wg.Wait()
16424
16425 for _, e := range ret {
16426 if e == graphql.Null {
16427 return graphql.Null
16428 }
16429 }
16430
16431 return ret
16432}
16433
16434func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
16435 return ec._TimelineItemConnection(ctx, sel, &v)
16436}
16437
16438func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
16439 if v == nil {
16440 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16441 ec.Errorf(ctx, "must not be null")
16442 }
16443 return graphql.Null
16444 }
16445 return ec._TimelineItemConnection(ctx, sel, v)
16446}
16447
16448func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
16449 ret := make(graphql.Array, len(v))
16450 var wg sync.WaitGroup
16451 isLen1 := len(v) == 1
16452 if !isLen1 {
16453 wg.Add(len(v))
16454 }
16455 for i := range v {
16456 i := i
16457 fc := &graphql.FieldContext{
16458 Index: &i,
16459 Result: &v[i],
16460 }
16461 ctx := graphql.WithFieldContext(ctx, fc)
16462 f := func(i int) {
16463 defer func() {
16464 if r := recover(); r != nil {
16465 ec.Error(ctx, ec.Recover(ctx, r))
16466 ret = nil
16467 }
16468 }()
16469 if !isLen1 {
16470 defer wg.Done()
16471 }
16472 ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
16473 }
16474 if isLen1 {
16475 f(i)
16476 } else {
16477 go f(i)
16478 }
16479
16480 }
16481 wg.Wait()
16482
16483 for _, e := range ret {
16484 if e == graphql.Null {
16485 return graphql.Null
16486 }
16487 }
16488
16489 return ret
16490}
16491
16492func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
16493 if v == nil {
16494 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16495 ec.Errorf(ctx, "must not be null")
16496 }
16497 return graphql.Null
16498 }
16499 return ec._TimelineItemEdge(ctx, sel, v)
16500}
16501
16502func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
16503 return ec.___Directive(ctx, sel, &v)
16504}
16505
16506func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
16507 ret := make(graphql.Array, len(v))
16508 var wg sync.WaitGroup
16509 isLen1 := len(v) == 1
16510 if !isLen1 {
16511 wg.Add(len(v))
16512 }
16513 for i := range v {
16514 i := i
16515 fc := &graphql.FieldContext{
16516 Index: &i,
16517 Result: &v[i],
16518 }
16519 ctx := graphql.WithFieldContext(ctx, fc)
16520 f := func(i int) {
16521 defer func() {
16522 if r := recover(); r != nil {
16523 ec.Error(ctx, ec.Recover(ctx, r))
16524 ret = nil
16525 }
16526 }()
16527 if !isLen1 {
16528 defer wg.Done()
16529 }
16530 ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
16531 }
16532 if isLen1 {
16533 f(i)
16534 } else {
16535 go f(i)
16536 }
16537
16538 }
16539 wg.Wait()
16540
16541 for _, e := range ret {
16542 if e == graphql.Null {
16543 return graphql.Null
16544 }
16545 }
16546
16547 return ret
16548}
16549
16550func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
16551 res, err := graphql.UnmarshalString(v)
16552 return res, graphql.ErrorOnPath(ctx, err)
16553}
16554
16555func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
16556 res := graphql.MarshalString(v)
16557 if res == graphql.Null {
16558 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16559 ec.Errorf(ctx, "must not be null")
16560 }
16561 }
16562 return res
16563}
16564
16565func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
16566 var vSlice []interface{}
16567 if v != nil {
16568 vSlice = graphql.CoerceList(v)
16569 }
16570 var err error
16571 res := make([]string, len(vSlice))
16572 for i := range vSlice {
16573 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
16574 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
16575 if err != nil {
16576 return nil, err
16577 }
16578 }
16579 return res, nil
16580}
16581
16582func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
16583 ret := make(graphql.Array, len(v))
16584 var wg sync.WaitGroup
16585 isLen1 := len(v) == 1
16586 if !isLen1 {
16587 wg.Add(len(v))
16588 }
16589 for i := range v {
16590 i := i
16591 fc := &graphql.FieldContext{
16592 Index: &i,
16593 Result: &v[i],
16594 }
16595 ctx := graphql.WithFieldContext(ctx, fc)
16596 f := func(i int) {
16597 defer func() {
16598 if r := recover(); r != nil {
16599 ec.Error(ctx, ec.Recover(ctx, r))
16600 ret = nil
16601 }
16602 }()
16603 if !isLen1 {
16604 defer wg.Done()
16605 }
16606 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
16607 }
16608 if isLen1 {
16609 f(i)
16610 } else {
16611 go f(i)
16612 }
16613
16614 }
16615 wg.Wait()
16616
16617 for _, e := range ret {
16618 if e == graphql.Null {
16619 return graphql.Null
16620 }
16621 }
16622
16623 return ret
16624}
16625
16626func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
16627 return ec.___EnumValue(ctx, sel, &v)
16628}
16629
16630func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
16631 return ec.___Field(ctx, sel, &v)
16632}
16633
16634func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
16635 return ec.___InputValue(ctx, sel, &v)
16636}
16637
16638func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
16639 ret := make(graphql.Array, len(v))
16640 var wg sync.WaitGroup
16641 isLen1 := len(v) == 1
16642 if !isLen1 {
16643 wg.Add(len(v))
16644 }
16645 for i := range v {
16646 i := i
16647 fc := &graphql.FieldContext{
16648 Index: &i,
16649 Result: &v[i],
16650 }
16651 ctx := graphql.WithFieldContext(ctx, fc)
16652 f := func(i int) {
16653 defer func() {
16654 if r := recover(); r != nil {
16655 ec.Error(ctx, ec.Recover(ctx, r))
16656 ret = nil
16657 }
16658 }()
16659 if !isLen1 {
16660 defer wg.Done()
16661 }
16662 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
16663 }
16664 if isLen1 {
16665 f(i)
16666 } else {
16667 go f(i)
16668 }
16669
16670 }
16671 wg.Wait()
16672
16673 for _, e := range ret {
16674 if e == graphql.Null {
16675 return graphql.Null
16676 }
16677 }
16678
16679 return ret
16680}
16681
16682func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
16683 return ec.___Type(ctx, sel, &v)
16684}
16685
16686func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
16687 ret := make(graphql.Array, len(v))
16688 var wg sync.WaitGroup
16689 isLen1 := len(v) == 1
16690 if !isLen1 {
16691 wg.Add(len(v))
16692 }
16693 for i := range v {
16694 i := i
16695 fc := &graphql.FieldContext{
16696 Index: &i,
16697 Result: &v[i],
16698 }
16699 ctx := graphql.WithFieldContext(ctx, fc)
16700 f := func(i int) {
16701 defer func() {
16702 if r := recover(); r != nil {
16703 ec.Error(ctx, ec.Recover(ctx, r))
16704 ret = nil
16705 }
16706 }()
16707 if !isLen1 {
16708 defer wg.Done()
16709 }
16710 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
16711 }
16712 if isLen1 {
16713 f(i)
16714 } else {
16715 go f(i)
16716 }
16717
16718 }
16719 wg.Wait()
16720
16721 for _, e := range ret {
16722 if e == graphql.Null {
16723 return graphql.Null
16724 }
16725 }
16726
16727 return ret
16728}
16729
16730func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
16731 if v == nil {
16732 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16733 ec.Errorf(ctx, "must not be null")
16734 }
16735 return graphql.Null
16736 }
16737 return ec.___Type(ctx, sel, v)
16738}
16739
16740func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
16741 res, err := graphql.UnmarshalString(v)
16742 return res, graphql.ErrorOnPath(ctx, err)
16743}
16744
16745func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
16746 res := graphql.MarshalString(v)
16747 if res == graphql.Null {
16748 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
16749 ec.Errorf(ctx, "must not be null")
16750 }
16751 }
16752 return res
16753}
16754
16755func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
16756 res, err := graphql.UnmarshalBoolean(v)
16757 return res, graphql.ErrorOnPath(ctx, err)
16758}
16759
16760func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
16761 res := graphql.MarshalBoolean(v)
16762 return res
16763}
16764
16765func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
16766 if v == nil {
16767 return nil, nil
16768 }
16769 res, err := graphql.UnmarshalBoolean(v)
16770 return &res, graphql.ErrorOnPath(ctx, err)
16771}
16772
16773func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
16774 if v == nil {
16775 return graphql.Null
16776 }
16777 res := graphql.MarshalBoolean(*v)
16778 return res
16779}
16780
16781func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
16782 if v == nil {
16783 return graphql.Null
16784 }
16785 return ec._Bug(ctx, sel, v)
16786}
16787
16788func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
16789 if v == nil {
16790 return nil, nil
16791 }
16792 res, err := ec.unmarshalInputChangeLabelInput(ctx, v)
16793 return &res, graphql.ErrorOnPath(ctx, err)
16794}
16795
16796func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, v interface{}) ([]repository.Hash, error) {
16797 if v == nil {
16798 return nil, nil
16799 }
16800 var vSlice []interface{}
16801 if v != nil {
16802 vSlice = graphql.CoerceList(v)
16803 }
16804 var err error
16805 res := make([]repository.Hash, len(vSlice))
16806 for i := range vSlice {
16807 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
16808 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, vSlice[i])
16809 if err != nil {
16810 return nil, err
16811 }
16812 }
16813 return res, nil
16814}
16815
16816func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []repository.Hash) graphql.Marshaler {
16817 if v == nil {
16818 return graphql.Null
16819 }
16820 ret := make(graphql.Array, len(v))
16821 for i := range v {
16822 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, sel, v[i])
16823 }
16824
16825 for _, e := range ret {
16826 if e == graphql.Null {
16827 return graphql.Null
16828 }
16829 }
16830
16831 return ret
16832}
16833
16834func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
16835 if v == nil {
16836 return graphql.Null
16837 }
16838 return ec._Identity(ctx, sel, v)
16839}
16840
16841func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
16842 if v == nil {
16843 return nil, nil
16844 }
16845 res, err := graphql.UnmarshalInt(v)
16846 return &res, graphql.ErrorOnPath(ctx, err)
16847}
16848
16849func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
16850 if v == nil {
16851 return graphql.Null
16852 }
16853 res := graphql.MarshalInt(*v)
16854 return res
16855}
16856
16857func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
16858 if v == nil {
16859 return graphql.Null
16860 }
16861 return ec._LabelChangeResult(ctx, sel, v)
16862}
16863
16864func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
16865 if v == nil {
16866 return graphql.Null
16867 }
16868 return ec._Repository(ctx, sel, v)
16869}
16870
16871func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
16872 res, err := graphql.UnmarshalString(v)
16873 return res, graphql.ErrorOnPath(ctx, err)
16874}
16875
16876func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
16877 res := graphql.MarshalString(v)
16878 return res
16879}
16880
16881func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
16882 if v == nil {
16883 return nil, nil
16884 }
16885 var vSlice []interface{}
16886 if v != nil {
16887 vSlice = graphql.CoerceList(v)
16888 }
16889 var err error
16890 res := make([]string, len(vSlice))
16891 for i := range vSlice {
16892 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
16893 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
16894 if err != nil {
16895 return nil, err
16896 }
16897 }
16898 return res, nil
16899}
16900
16901func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
16902 if v == nil {
16903 return graphql.Null
16904 }
16905 ret := make(graphql.Array, len(v))
16906 for i := range v {
16907 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
16908 }
16909
16910 for _, e := range ret {
16911 if e == graphql.Null {
16912 return graphql.Null
16913 }
16914 }
16915
16916 return ret
16917}
16918
16919func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
16920 if v == nil {
16921 return nil, nil
16922 }
16923 res, err := graphql.UnmarshalString(v)
16924 return &res, graphql.ErrorOnPath(ctx, err)
16925}
16926
16927func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
16928 if v == nil {
16929 return graphql.Null
16930 }
16931 res := graphql.MarshalString(*v)
16932 return res
16933}
16934
16935func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
16936 if v == nil {
16937 return graphql.Null
16938 }
16939 ret := make(graphql.Array, len(v))
16940 var wg sync.WaitGroup
16941 isLen1 := len(v) == 1
16942 if !isLen1 {
16943 wg.Add(len(v))
16944 }
16945 for i := range v {
16946 i := i
16947 fc := &graphql.FieldContext{
16948 Index: &i,
16949 Result: &v[i],
16950 }
16951 ctx := graphql.WithFieldContext(ctx, fc)
16952 f := func(i int) {
16953 defer func() {
16954 if r := recover(); r != nil {
16955 ec.Error(ctx, ec.Recover(ctx, r))
16956 ret = nil
16957 }
16958 }()
16959 if !isLen1 {
16960 defer wg.Done()
16961 }
16962 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
16963 }
16964 if isLen1 {
16965 f(i)
16966 } else {
16967 go f(i)
16968 }
16969
16970 }
16971 wg.Wait()
16972
16973 for _, e := range ret {
16974 if e == graphql.Null {
16975 return graphql.Null
16976 }
16977 }
16978
16979 return ret
16980}
16981
16982func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
16983 if v == nil {
16984 return graphql.Null
16985 }
16986 ret := make(graphql.Array, len(v))
16987 var wg sync.WaitGroup
16988 isLen1 := len(v) == 1
16989 if !isLen1 {
16990 wg.Add(len(v))
16991 }
16992 for i := range v {
16993 i := i
16994 fc := &graphql.FieldContext{
16995 Index: &i,
16996 Result: &v[i],
16997 }
16998 ctx := graphql.WithFieldContext(ctx, fc)
16999 f := func(i int) {
17000 defer func() {
17001 if r := recover(); r != nil {
17002 ec.Error(ctx, ec.Recover(ctx, r))
17003 ret = nil
17004 }
17005 }()
17006 if !isLen1 {
17007 defer wg.Done()
17008 }
17009 ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
17010 }
17011 if isLen1 {
17012 f(i)
17013 } else {
17014 go f(i)
17015 }
17016
17017 }
17018 wg.Wait()
17019
17020 for _, e := range ret {
17021 if e == graphql.Null {
17022 return graphql.Null
17023 }
17024 }
17025
17026 return ret
17027}
17028
17029func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
17030 if v == nil {
17031 return graphql.Null
17032 }
17033 ret := make(graphql.Array, len(v))
17034 var wg sync.WaitGroup
17035 isLen1 := len(v) == 1
17036 if !isLen1 {
17037 wg.Add(len(v))
17038 }
17039 for i := range v {
17040 i := i
17041 fc := &graphql.FieldContext{
17042 Index: &i,
17043 Result: &v[i],
17044 }
17045 ctx := graphql.WithFieldContext(ctx, fc)
17046 f := func(i int) {
17047 defer func() {
17048 if r := recover(); r != nil {
17049 ec.Error(ctx, ec.Recover(ctx, r))
17050 ret = nil
17051 }
17052 }()
17053 if !isLen1 {
17054 defer wg.Done()
17055 }
17056 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
17057 }
17058 if isLen1 {
17059 f(i)
17060 } else {
17061 go f(i)
17062 }
17063
17064 }
17065 wg.Wait()
17066
17067 for _, e := range ret {
17068 if e == graphql.Null {
17069 return graphql.Null
17070 }
17071 }
17072
17073 return ret
17074}
17075
17076func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
17077 if v == nil {
17078 return graphql.Null
17079 }
17080 return ec.___Schema(ctx, sel, v)
17081}
17082
17083func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
17084 if v == nil {
17085 return graphql.Null
17086 }
17087 ret := make(graphql.Array, len(v))
17088 var wg sync.WaitGroup
17089 isLen1 := len(v) == 1
17090 if !isLen1 {
17091 wg.Add(len(v))
17092 }
17093 for i := range v {
17094 i := i
17095 fc := &graphql.FieldContext{
17096 Index: &i,
17097 Result: &v[i],
17098 }
17099 ctx := graphql.WithFieldContext(ctx, fc)
17100 f := func(i int) {
17101 defer func() {
17102 if r := recover(); r != nil {
17103 ec.Error(ctx, ec.Recover(ctx, r))
17104 ret = nil
17105 }
17106 }()
17107 if !isLen1 {
17108 defer wg.Done()
17109 }
17110 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
17111 }
17112 if isLen1 {
17113 f(i)
17114 } else {
17115 go f(i)
17116 }
17117
17118 }
17119 wg.Wait()
17120
17121 for _, e := range ret {
17122 if e == graphql.Null {
17123 return graphql.Null
17124 }
17125 }
17126
17127 return ret
17128}
17129
17130func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
17131 if v == nil {
17132 return graphql.Null
17133 }
17134 return ec.___Type(ctx, sel, v)
17135}
17136
17137// endregion ***************************** type.gotpl *****************************