1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
2
3package graph
4
5import (
6 "bytes"
7 "context"
8 "errors"
9 "fmt"
10 "image/color"
11 "strconv"
12 "sync"
13 "sync/atomic"
14 "time"
15
16 "github.com/99designs/gqlgen/graphql"
17 "github.com/99designs/gqlgen/graphql/introspection"
18 "github.com/MichaelMure/git-bug/api/graphql/models"
19 "github.com/MichaelMure/git-bug/bug"
20 "github.com/MichaelMure/git-bug/repository"
21 "github.com/vektah/gqlparser"
22 "github.com/vektah/gqlparser/ast"
23)
24
25// region ************************** generated!.gotpl **************************
26
27// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
28func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
29 return &executableSchema{
30 resolvers: cfg.Resolvers,
31 directives: cfg.Directives,
32 complexity: cfg.Complexity,
33 }
34}
35
36type Config struct {
37 Resolvers ResolverRoot
38 Directives DirectiveRoot
39 Complexity ComplexityRoot
40}
41
42type ResolverRoot interface {
43 AddCommentOperation() AddCommentOperationResolver
44 AddCommentTimelineItem() AddCommentTimelineItemResolver
45 Bug() BugResolver
46 Color() ColorResolver
47 Comment() CommentResolver
48 CommentHistoryStep() CommentHistoryStepResolver
49 CreateOperation() CreateOperationResolver
50 CreateTimelineItem() CreateTimelineItemResolver
51 EditCommentOperation() EditCommentOperationResolver
52 Identity() IdentityResolver
53 Label() LabelResolver
54 LabelChangeOperation() LabelChangeOperationResolver
55 LabelChangeResult() LabelChangeResultResolver
56 LabelChangeTimelineItem() LabelChangeTimelineItemResolver
57 Mutation() MutationResolver
58 Query() QueryResolver
59 Repository() RepositoryResolver
60 SetStatusOperation() SetStatusOperationResolver
61 SetStatusTimelineItem() SetStatusTimelineItemResolver
62 SetTitleOperation() SetTitleOperationResolver
63 SetTitleTimelineItem() SetTitleTimelineItemResolver
64}
65
66type DirectiveRoot struct {
67}
68
69type ComplexityRoot struct {
70 AddCommentAndCloseBugPayload struct {
71 Bug func(childComplexity int) int
72 ClientMutationID func(childComplexity int) int
73 CommentOperation func(childComplexity int) int
74 StatusOperation func(childComplexity int) int
75 }
76
77 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 &ast.Source{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 &ast.Source{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 &ast.Source{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 &ast.Source{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 &ast.Source{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 &ast.Source{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 &ast.Source{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 &ast.Source{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 &ast.Source{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 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2652 if err != nil {
2653 return nil, err
2654 }
2655 }
2656 args["after"] = arg0
2657 var arg1 *string
2658 if tmp, ok := rawArgs["before"]; ok {
2659 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2660 if err != nil {
2661 return nil, err
2662 }
2663 }
2664 args["before"] = arg1
2665 var arg2 *int
2666 if tmp, ok := rawArgs["first"]; ok {
2667 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2668 if err != nil {
2669 return nil, err
2670 }
2671 }
2672 args["first"] = arg2
2673 var arg3 *int
2674 if tmp, ok := rawArgs["last"]; ok {
2675 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2676 if err != nil {
2677 return nil, err
2678 }
2679 }
2680 args["last"] = arg3
2681 return args, nil
2682}
2683
2684func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2685 var err error
2686 args := map[string]interface{}{}
2687 var arg0 *string
2688 if tmp, ok := rawArgs["after"]; ok {
2689 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2690 if err != nil {
2691 return nil, err
2692 }
2693 }
2694 args["after"] = arg0
2695 var arg1 *string
2696 if tmp, ok := rawArgs["before"]; ok {
2697 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2698 if err != nil {
2699 return nil, err
2700 }
2701 }
2702 args["before"] = arg1
2703 var arg2 *int
2704 if tmp, ok := rawArgs["first"]; ok {
2705 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2706 if err != nil {
2707 return nil, err
2708 }
2709 }
2710 args["first"] = arg2
2711 var arg3 *int
2712 if tmp, ok := rawArgs["last"]; ok {
2713 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2714 if err != nil {
2715 return nil, err
2716 }
2717 }
2718 args["last"] = arg3
2719 return args, nil
2720}
2721
2722func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2723 var err error
2724 args := map[string]interface{}{}
2725 var arg0 *string
2726 if tmp, ok := rawArgs["after"]; ok {
2727 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2728 if err != nil {
2729 return nil, err
2730 }
2731 }
2732 args["after"] = arg0
2733 var arg1 *string
2734 if tmp, ok := rawArgs["before"]; ok {
2735 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2736 if err != nil {
2737 return nil, err
2738 }
2739 }
2740 args["before"] = arg1
2741 var arg2 *int
2742 if tmp, ok := rawArgs["first"]; ok {
2743 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2744 if err != nil {
2745 return nil, err
2746 }
2747 }
2748 args["first"] = arg2
2749 var arg3 *int
2750 if tmp, ok := rawArgs["last"]; ok {
2751 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2752 if err != nil {
2753 return nil, err
2754 }
2755 }
2756 args["last"] = arg3
2757 return args, nil
2758}
2759
2760func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2761 var err error
2762 args := map[string]interface{}{}
2763 var arg0 *string
2764 if tmp, ok := rawArgs["after"]; ok {
2765 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2766 if err != nil {
2767 return nil, err
2768 }
2769 }
2770 args["after"] = arg0
2771 var arg1 *string
2772 if tmp, ok := rawArgs["before"]; ok {
2773 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2774 if err != nil {
2775 return nil, err
2776 }
2777 }
2778 args["before"] = arg1
2779 var arg2 *int
2780 if tmp, ok := rawArgs["first"]; ok {
2781 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2782 if err != nil {
2783 return nil, err
2784 }
2785 }
2786 args["first"] = arg2
2787 var arg3 *int
2788 if tmp, ok := rawArgs["last"]; ok {
2789 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2790 if err != nil {
2791 return nil, err
2792 }
2793 }
2794 args["last"] = arg3
2795 return args, nil
2796}
2797
2798func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2799 var err error
2800 args := map[string]interface{}{}
2801 var arg0 *string
2802 if tmp, ok := rawArgs["after"]; ok {
2803 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2804 if err != nil {
2805 return nil, err
2806 }
2807 }
2808 args["after"] = arg0
2809 var arg1 *string
2810 if tmp, ok := rawArgs["before"]; ok {
2811 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2812 if err != nil {
2813 return nil, err
2814 }
2815 }
2816 args["before"] = arg1
2817 var arg2 *int
2818 if tmp, ok := rawArgs["first"]; ok {
2819 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2820 if err != nil {
2821 return nil, err
2822 }
2823 }
2824 args["first"] = arg2
2825 var arg3 *int
2826 if tmp, ok := rawArgs["last"]; ok {
2827 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2828 if err != nil {
2829 return nil, err
2830 }
2831 }
2832 args["last"] = arg3
2833 return args, nil
2834}
2835
2836func (ec *executionContext) field_Mutation_addCommentAndClose_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2837 var err error
2838 args := map[string]interface{}{}
2839 var arg0 models.AddCommentAndCloseBugInput
2840 if tmp, ok := rawArgs["input"]; ok {
2841 arg0, err = ec.unmarshalNAddCommentAndCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugInput(ctx, tmp)
2842 if err != nil {
2843 return nil, err
2844 }
2845 }
2846 args["input"] = arg0
2847 return args, nil
2848}
2849
2850func (ec *executionContext) field_Mutation_addCommentAndReopen_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2851 var err error
2852 args := map[string]interface{}{}
2853 var arg0 models.AddCommentAndReopenBugInput
2854 if tmp, ok := rawArgs["input"]; ok {
2855 arg0, err = ec.unmarshalNAddCommentAndReopenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugInput(ctx, tmp)
2856 if err != nil {
2857 return nil, err
2858 }
2859 }
2860 args["input"] = arg0
2861 return args, nil
2862}
2863
2864func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2865 var err error
2866 args := map[string]interface{}{}
2867 var arg0 models.AddCommentInput
2868 if tmp, ok := rawArgs["input"]; ok {
2869 arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
2870 if err != nil {
2871 return nil, err
2872 }
2873 }
2874 args["input"] = arg0
2875 return args, nil
2876}
2877
2878func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2879 var err error
2880 args := map[string]interface{}{}
2881 var arg0 *models.ChangeLabelInput
2882 if tmp, ok := rawArgs["input"]; ok {
2883 arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
2884 if err != nil {
2885 return nil, err
2886 }
2887 }
2888 args["input"] = arg0
2889 return args, nil
2890}
2891
2892func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2893 var err error
2894 args := map[string]interface{}{}
2895 var arg0 models.CloseBugInput
2896 if tmp, ok := rawArgs["input"]; ok {
2897 arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
2898 if err != nil {
2899 return nil, err
2900 }
2901 }
2902 args["input"] = arg0
2903 return args, nil
2904}
2905
2906func (ec *executionContext) field_Mutation_editComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2907 var err error
2908 args := map[string]interface{}{}
2909 var arg0 models.EditCommentInput
2910 if tmp, ok := rawArgs["input"]; ok {
2911 arg0, err = ec.unmarshalNEditCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx, tmp)
2912 if err != nil {
2913 return nil, err
2914 }
2915 }
2916 args["input"] = arg0
2917 return args, nil
2918}
2919
2920func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2921 var err error
2922 args := map[string]interface{}{}
2923 var arg0 models.NewBugInput
2924 if tmp, ok := rawArgs["input"]; ok {
2925 arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
2926 if err != nil {
2927 return nil, err
2928 }
2929 }
2930 args["input"] = arg0
2931 return args, nil
2932}
2933
2934func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2935 var err error
2936 args := map[string]interface{}{}
2937 var arg0 models.OpenBugInput
2938 if tmp, ok := rawArgs["input"]; ok {
2939 arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
2940 if err != nil {
2941 return nil, err
2942 }
2943 }
2944 args["input"] = arg0
2945 return args, nil
2946}
2947
2948func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2949 var err error
2950 args := map[string]interface{}{}
2951 var arg0 models.SetTitleInput
2952 if tmp, ok := rawArgs["input"]; ok {
2953 arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
2954 if err != nil {
2955 return nil, err
2956 }
2957 }
2958 args["input"] = arg0
2959 return args, nil
2960}
2961
2962func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2963 var err error
2964 args := map[string]interface{}{}
2965 var arg0 string
2966 if tmp, ok := rawArgs["name"]; ok {
2967 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2968 if err != nil {
2969 return nil, err
2970 }
2971 }
2972 args["name"] = arg0
2973 return args, nil
2974}
2975
2976func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2977 var err error
2978 args := map[string]interface{}{}
2979 var arg0 *string
2980 if tmp, ok := rawArgs["ref"]; ok {
2981 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2982 if err != nil {
2983 return nil, err
2984 }
2985 }
2986 args["ref"] = arg0
2987 return args, nil
2988}
2989
2990func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2991 var err error
2992 args := map[string]interface{}{}
2993 var arg0 *string
2994 if tmp, ok := rawArgs["after"]; ok {
2995 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2996 if err != nil {
2997 return nil, err
2998 }
2999 }
3000 args["after"] = arg0
3001 var arg1 *string
3002 if tmp, ok := rawArgs["before"]; ok {
3003 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3004 if err != nil {
3005 return nil, err
3006 }
3007 }
3008 args["before"] = arg1
3009 var arg2 *int
3010 if tmp, ok := rawArgs["first"]; ok {
3011 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3012 if err != nil {
3013 return nil, err
3014 }
3015 }
3016 args["first"] = arg2
3017 var arg3 *int
3018 if tmp, ok := rawArgs["last"]; ok {
3019 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3020 if err != nil {
3021 return nil, err
3022 }
3023 }
3024 args["last"] = arg3
3025 var arg4 *string
3026 if tmp, ok := rawArgs["query"]; ok {
3027 arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3028 if err != nil {
3029 return nil, err
3030 }
3031 }
3032 args["query"] = arg4
3033 return args, nil
3034}
3035
3036func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3037 var err error
3038 args := map[string]interface{}{}
3039 var arg0 *string
3040 if tmp, ok := rawArgs["after"]; ok {
3041 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3042 if err != nil {
3043 return nil, err
3044 }
3045 }
3046 args["after"] = arg0
3047 var arg1 *string
3048 if tmp, ok := rawArgs["before"]; ok {
3049 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3050 if err != nil {
3051 return nil, err
3052 }
3053 }
3054 args["before"] = arg1
3055 var arg2 *int
3056 if tmp, ok := rawArgs["first"]; ok {
3057 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3058 if err != nil {
3059 return nil, err
3060 }
3061 }
3062 args["first"] = arg2
3063 var arg3 *int
3064 if tmp, ok := rawArgs["last"]; ok {
3065 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3066 if err != nil {
3067 return nil, err
3068 }
3069 }
3070 args["last"] = arg3
3071 return args, nil
3072}
3073
3074func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3075 var err error
3076 args := map[string]interface{}{}
3077 var arg0 string
3078 if tmp, ok := rawArgs["prefix"]; ok {
3079 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3080 if err != nil {
3081 return nil, err
3082 }
3083 }
3084 args["prefix"] = arg0
3085 return args, nil
3086}
3087
3088func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3089 var err error
3090 args := map[string]interface{}{}
3091 var arg0 string
3092 if tmp, ok := rawArgs["prefix"]; ok {
3093 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3094 if err != nil {
3095 return nil, err
3096 }
3097 }
3098 args["prefix"] = arg0
3099 return args, nil
3100}
3101
3102func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3103 var err error
3104 args := map[string]interface{}{}
3105 var arg0 *string
3106 if tmp, ok := rawArgs["after"]; ok {
3107 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3108 if err != nil {
3109 return nil, err
3110 }
3111 }
3112 args["after"] = arg0
3113 var arg1 *string
3114 if tmp, ok := rawArgs["before"]; ok {
3115 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3116 if err != nil {
3117 return nil, err
3118 }
3119 }
3120 args["before"] = arg1
3121 var arg2 *int
3122 if tmp, ok := rawArgs["first"]; ok {
3123 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3124 if err != nil {
3125 return nil, err
3126 }
3127 }
3128 args["first"] = arg2
3129 var arg3 *int
3130 if tmp, ok := rawArgs["last"]; ok {
3131 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3132 if err != nil {
3133 return nil, err
3134 }
3135 }
3136 args["last"] = arg3
3137 return args, nil
3138}
3139
3140func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3141 var err error
3142 args := map[string]interface{}{}
3143 var arg0 bool
3144 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3145 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3146 if err != nil {
3147 return nil, err
3148 }
3149 }
3150 args["includeDeprecated"] = arg0
3151 return args, nil
3152}
3153
3154func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3155 var err error
3156 args := map[string]interface{}{}
3157 var arg0 bool
3158 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3159 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3160 if err != nil {
3161 return nil, err
3162 }
3163 }
3164 args["includeDeprecated"] = arg0
3165 return args, nil
3166}
3167
3168// endregion ***************************** args.gotpl *****************************
3169
3170// region ************************** directives.gotpl **************************
3171
3172// endregion ************************** directives.gotpl **************************
3173
3174// region **************************** field.gotpl *****************************
3175
3176func (ec *executionContext) _AddCommentAndCloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3177 defer func() {
3178 if r := recover(); r != nil {
3179 ec.Error(ctx, ec.Recover(ctx, r))
3180 ret = graphql.Null
3181 }
3182 }()
3183 fc := &graphql.FieldContext{
3184 Object: "AddCommentAndCloseBugPayload",
3185 Field: field,
3186 Args: nil,
3187 IsMethod: false,
3188 }
3189
3190 ctx = graphql.WithFieldContext(ctx, fc)
3191 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3192 ctx = rctx // use context from middleware stack in children
3193 return obj.ClientMutationID, nil
3194 })
3195 if err != nil {
3196 ec.Error(ctx, err)
3197 return graphql.Null
3198 }
3199 if resTmp == nil {
3200 return graphql.Null
3201 }
3202 res := resTmp.(*string)
3203 fc.Result = res
3204 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3205}
3206
3207func (ec *executionContext) _AddCommentAndCloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3208 defer func() {
3209 if r := recover(); r != nil {
3210 ec.Error(ctx, ec.Recover(ctx, r))
3211 ret = graphql.Null
3212 }
3213 }()
3214 fc := &graphql.FieldContext{
3215 Object: "AddCommentAndCloseBugPayload",
3216 Field: field,
3217 Args: nil,
3218 IsMethod: false,
3219 }
3220
3221 ctx = graphql.WithFieldContext(ctx, fc)
3222 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3223 ctx = rctx // use context from middleware stack in children
3224 return obj.Bug, nil
3225 })
3226 if err != nil {
3227 ec.Error(ctx, err)
3228 return graphql.Null
3229 }
3230 if resTmp == nil {
3231 if !graphql.HasFieldError(ctx, fc) {
3232 ec.Errorf(ctx, "must not be null")
3233 }
3234 return graphql.Null
3235 }
3236 res := resTmp.(models.BugWrapper)
3237 fc.Result = res
3238 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
3239}
3240
3241func (ec *executionContext) _AddCommentAndCloseBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3242 defer func() {
3243 if r := recover(); r != nil {
3244 ec.Error(ctx, ec.Recover(ctx, r))
3245 ret = graphql.Null
3246 }
3247 }()
3248 fc := &graphql.FieldContext{
3249 Object: "AddCommentAndCloseBugPayload",
3250 Field: field,
3251 Args: nil,
3252 IsMethod: false,
3253 }
3254
3255 ctx = graphql.WithFieldContext(ctx, fc)
3256 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3257 ctx = rctx // use context from middleware stack in children
3258 return obj.CommentOperation, nil
3259 })
3260 if err != nil {
3261 ec.Error(ctx, err)
3262 return graphql.Null
3263 }
3264 if resTmp == nil {
3265 if !graphql.HasFieldError(ctx, fc) {
3266 ec.Errorf(ctx, "must not be null")
3267 }
3268 return graphql.Null
3269 }
3270 res := resTmp.(*bug.AddCommentOperation)
3271 fc.Result = res
3272 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3273}
3274
3275func (ec *executionContext) _AddCommentAndCloseBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
3276 defer func() {
3277 if r := recover(); r != nil {
3278 ec.Error(ctx, ec.Recover(ctx, r))
3279 ret = graphql.Null
3280 }
3281 }()
3282 fc := &graphql.FieldContext{
3283 Object: "AddCommentAndCloseBugPayload",
3284 Field: field,
3285 Args: nil,
3286 IsMethod: false,
3287 }
3288
3289 ctx = graphql.WithFieldContext(ctx, fc)
3290 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3291 ctx = rctx // use context from middleware stack in children
3292 return obj.StatusOperation, nil
3293 })
3294 if err != nil {
3295 ec.Error(ctx, err)
3296 return graphql.Null
3297 }
3298 if resTmp == nil {
3299 if !graphql.HasFieldError(ctx, fc) {
3300 ec.Errorf(ctx, "must not be null")
3301 }
3302 return graphql.Null
3303 }
3304 res := resTmp.(*bug.SetStatusOperation)
3305 fc.Result = res
3306 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
3307}
3308
3309func (ec *executionContext) _AddCommentAndReopenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
3310 defer func() {
3311 if r := recover(); r != nil {
3312 ec.Error(ctx, ec.Recover(ctx, r))
3313 ret = graphql.Null
3314 }
3315 }()
3316 fc := &graphql.FieldContext{
3317 Object: "AddCommentAndReopenBugPayload",
3318 Field: field,
3319 Args: nil,
3320 IsMethod: false,
3321 }
3322
3323 ctx = graphql.WithFieldContext(ctx, fc)
3324 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3325 ctx = rctx // use context from middleware stack in children
3326 return obj.ClientMutationID, nil
3327 })
3328 if err != nil {
3329 ec.Error(ctx, err)
3330 return graphql.Null
3331 }
3332 if resTmp == nil {
3333 return graphql.Null
3334 }
3335 res := resTmp.(*string)
3336 fc.Result = res
3337 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3338}
3339
3340func (ec *executionContext) _AddCommentAndReopenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
3341 defer func() {
3342 if r := recover(); r != nil {
3343 ec.Error(ctx, ec.Recover(ctx, r))
3344 ret = graphql.Null
3345 }
3346 }()
3347 fc := &graphql.FieldContext{
3348 Object: "AddCommentAndReopenBugPayload",
3349 Field: field,
3350 Args: nil,
3351 IsMethod: false,
3352 }
3353
3354 ctx = graphql.WithFieldContext(ctx, fc)
3355 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3356 ctx = rctx // use context from middleware stack in children
3357 return obj.Bug, nil
3358 })
3359 if err != nil {
3360 ec.Error(ctx, err)
3361 return graphql.Null
3362 }
3363 if resTmp == nil {
3364 if !graphql.HasFieldError(ctx, fc) {
3365 ec.Errorf(ctx, "must not be null")
3366 }
3367 return graphql.Null
3368 }
3369 res := resTmp.(models.BugWrapper)
3370 fc.Result = res
3371 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
3372}
3373
3374func (ec *executionContext) _AddCommentAndReopenBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
3375 defer func() {
3376 if r := recover(); r != nil {
3377 ec.Error(ctx, ec.Recover(ctx, r))
3378 ret = graphql.Null
3379 }
3380 }()
3381 fc := &graphql.FieldContext{
3382 Object: "AddCommentAndReopenBugPayload",
3383 Field: field,
3384 Args: nil,
3385 IsMethod: false,
3386 }
3387
3388 ctx = graphql.WithFieldContext(ctx, fc)
3389 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3390 ctx = rctx // use context from middleware stack in children
3391 return obj.CommentOperation, nil
3392 })
3393 if err != nil {
3394 ec.Error(ctx, err)
3395 return graphql.Null
3396 }
3397 if resTmp == nil {
3398 if !graphql.HasFieldError(ctx, fc) {
3399 ec.Errorf(ctx, "must not be null")
3400 }
3401 return graphql.Null
3402 }
3403 res := resTmp.(*bug.AddCommentOperation)
3404 fc.Result = res
3405 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3406}
3407
3408func (ec *executionContext) _AddCommentAndReopenBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
3409 defer func() {
3410 if r := recover(); r != nil {
3411 ec.Error(ctx, ec.Recover(ctx, r))
3412 ret = graphql.Null
3413 }
3414 }()
3415 fc := &graphql.FieldContext{
3416 Object: "AddCommentAndReopenBugPayload",
3417 Field: field,
3418 Args: nil,
3419 IsMethod: false,
3420 }
3421
3422 ctx = graphql.WithFieldContext(ctx, fc)
3423 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3424 ctx = rctx // use context from middleware stack in children
3425 return obj.StatusOperation, nil
3426 })
3427 if err != nil {
3428 ec.Error(ctx, err)
3429 return graphql.Null
3430 }
3431 if resTmp == nil {
3432 if !graphql.HasFieldError(ctx, fc) {
3433 ec.Errorf(ctx, "must not be null")
3434 }
3435 return graphql.Null
3436 }
3437 res := resTmp.(*bug.SetStatusOperation)
3438 fc.Result = res
3439 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
3440}
3441
3442func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3443 defer func() {
3444 if r := recover(); r != nil {
3445 ec.Error(ctx, ec.Recover(ctx, r))
3446 ret = graphql.Null
3447 }
3448 }()
3449 fc := &graphql.FieldContext{
3450 Object: "AddCommentOperation",
3451 Field: field,
3452 Args: nil,
3453 IsMethod: true,
3454 }
3455
3456 ctx = graphql.WithFieldContext(ctx, fc)
3457 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3458 ctx = rctx // use context from middleware stack in children
3459 return ec.resolvers.AddCommentOperation().ID(rctx, obj)
3460 })
3461 if err != nil {
3462 ec.Error(ctx, err)
3463 return graphql.Null
3464 }
3465 if resTmp == nil {
3466 if !graphql.HasFieldError(ctx, fc) {
3467 ec.Errorf(ctx, "must not be null")
3468 }
3469 return graphql.Null
3470 }
3471 res := resTmp.(string)
3472 fc.Result = res
3473 return ec.marshalNString2string(ctx, field.Selections, res)
3474}
3475
3476func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3477 defer func() {
3478 if r := recover(); r != nil {
3479 ec.Error(ctx, ec.Recover(ctx, r))
3480 ret = graphql.Null
3481 }
3482 }()
3483 fc := &graphql.FieldContext{
3484 Object: "AddCommentOperation",
3485 Field: field,
3486 Args: nil,
3487 IsMethod: true,
3488 }
3489
3490 ctx = graphql.WithFieldContext(ctx, fc)
3491 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3492 ctx = rctx // use context from middleware stack in children
3493 return ec.resolvers.AddCommentOperation().Author(rctx, obj)
3494 })
3495 if err != nil {
3496 ec.Error(ctx, err)
3497 return graphql.Null
3498 }
3499 if resTmp == nil {
3500 if !graphql.HasFieldError(ctx, fc) {
3501 ec.Errorf(ctx, "must not be null")
3502 }
3503 return graphql.Null
3504 }
3505 res := resTmp.(models.IdentityWrapper)
3506 fc.Result = res
3507 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3508}
3509
3510func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3511 defer func() {
3512 if r := recover(); r != nil {
3513 ec.Error(ctx, ec.Recover(ctx, r))
3514 ret = graphql.Null
3515 }
3516 }()
3517 fc := &graphql.FieldContext{
3518 Object: "AddCommentOperation",
3519 Field: field,
3520 Args: nil,
3521 IsMethod: true,
3522 }
3523
3524 ctx = graphql.WithFieldContext(ctx, fc)
3525 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3526 ctx = rctx // use context from middleware stack in children
3527 return ec.resolvers.AddCommentOperation().Date(rctx, obj)
3528 })
3529 if err != nil {
3530 ec.Error(ctx, err)
3531 return graphql.Null
3532 }
3533 if resTmp == nil {
3534 if !graphql.HasFieldError(ctx, fc) {
3535 ec.Errorf(ctx, "must not be null")
3536 }
3537 return graphql.Null
3538 }
3539 res := resTmp.(*time.Time)
3540 fc.Result = res
3541 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3542}
3543
3544func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3545 defer func() {
3546 if r := recover(); r != nil {
3547 ec.Error(ctx, ec.Recover(ctx, r))
3548 ret = graphql.Null
3549 }
3550 }()
3551 fc := &graphql.FieldContext{
3552 Object: "AddCommentOperation",
3553 Field: field,
3554 Args: nil,
3555 IsMethod: false,
3556 }
3557
3558 ctx = graphql.WithFieldContext(ctx, fc)
3559 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3560 ctx = rctx // use context from middleware stack in children
3561 return obj.Message, nil
3562 })
3563 if err != nil {
3564 ec.Error(ctx, err)
3565 return graphql.Null
3566 }
3567 if resTmp == nil {
3568 if !graphql.HasFieldError(ctx, fc) {
3569 ec.Errorf(ctx, "must not be null")
3570 }
3571 return graphql.Null
3572 }
3573 res := resTmp.(string)
3574 fc.Result = res
3575 return ec.marshalNString2string(ctx, field.Selections, res)
3576}
3577
3578func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3579 defer func() {
3580 if r := recover(); r != nil {
3581 ec.Error(ctx, ec.Recover(ctx, r))
3582 ret = graphql.Null
3583 }
3584 }()
3585 fc := &graphql.FieldContext{
3586 Object: "AddCommentOperation",
3587 Field: field,
3588 Args: nil,
3589 IsMethod: false,
3590 }
3591
3592 ctx = graphql.WithFieldContext(ctx, fc)
3593 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3594 ctx = rctx // use context from middleware stack in children
3595 return obj.Files, nil
3596 })
3597 if err != nil {
3598 ec.Error(ctx, err)
3599 return graphql.Null
3600 }
3601 if resTmp == nil {
3602 if !graphql.HasFieldError(ctx, fc) {
3603 ec.Errorf(ctx, "must not be null")
3604 }
3605 return graphql.Null
3606 }
3607 res := resTmp.([]repository.Hash)
3608 fc.Result = res
3609 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
3610}
3611
3612func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3613 defer func() {
3614 if r := recover(); r != nil {
3615 ec.Error(ctx, ec.Recover(ctx, r))
3616 ret = graphql.Null
3617 }
3618 }()
3619 fc := &graphql.FieldContext{
3620 Object: "AddCommentPayload",
3621 Field: field,
3622 Args: nil,
3623 IsMethod: false,
3624 }
3625
3626 ctx = graphql.WithFieldContext(ctx, fc)
3627 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3628 ctx = rctx // use context from middleware stack in children
3629 return obj.ClientMutationID, nil
3630 })
3631 if err != nil {
3632 ec.Error(ctx, err)
3633 return graphql.Null
3634 }
3635 if resTmp == nil {
3636 return graphql.Null
3637 }
3638 res := resTmp.(*string)
3639 fc.Result = res
3640 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3641}
3642
3643func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3644 defer func() {
3645 if r := recover(); r != nil {
3646 ec.Error(ctx, ec.Recover(ctx, r))
3647 ret = graphql.Null
3648 }
3649 }()
3650 fc := &graphql.FieldContext{
3651 Object: "AddCommentPayload",
3652 Field: field,
3653 Args: nil,
3654 IsMethod: false,
3655 }
3656
3657 ctx = graphql.WithFieldContext(ctx, fc)
3658 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3659 ctx = rctx // use context from middleware stack in children
3660 return obj.Bug, nil
3661 })
3662 if err != nil {
3663 ec.Error(ctx, err)
3664 return graphql.Null
3665 }
3666 if resTmp == nil {
3667 if !graphql.HasFieldError(ctx, fc) {
3668 ec.Errorf(ctx, "must not be null")
3669 }
3670 return graphql.Null
3671 }
3672 res := resTmp.(models.BugWrapper)
3673 fc.Result = res
3674 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
3675}
3676
3677func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3678 defer func() {
3679 if r := recover(); r != nil {
3680 ec.Error(ctx, ec.Recover(ctx, r))
3681 ret = graphql.Null
3682 }
3683 }()
3684 fc := &graphql.FieldContext{
3685 Object: "AddCommentPayload",
3686 Field: field,
3687 Args: nil,
3688 IsMethod: false,
3689 }
3690
3691 ctx = graphql.WithFieldContext(ctx, fc)
3692 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3693 ctx = rctx // use context from middleware stack in children
3694 return obj.Operation, nil
3695 })
3696 if err != nil {
3697 ec.Error(ctx, err)
3698 return graphql.Null
3699 }
3700 if resTmp == nil {
3701 if !graphql.HasFieldError(ctx, fc) {
3702 ec.Errorf(ctx, "must not be null")
3703 }
3704 return graphql.Null
3705 }
3706 res := resTmp.(*bug.AddCommentOperation)
3707 fc.Result = res
3708 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3709}
3710
3711func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3712 defer func() {
3713 if r := recover(); r != nil {
3714 ec.Error(ctx, ec.Recover(ctx, r))
3715 ret = graphql.Null
3716 }
3717 }()
3718 fc := &graphql.FieldContext{
3719 Object: "AddCommentTimelineItem",
3720 Field: field,
3721 Args: nil,
3722 IsMethod: true,
3723 }
3724
3725 ctx = graphql.WithFieldContext(ctx, fc)
3726 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3727 ctx = rctx // use context from middleware stack in children
3728 return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
3729 })
3730 if err != nil {
3731 ec.Error(ctx, err)
3732 return graphql.Null
3733 }
3734 if resTmp == nil {
3735 if !graphql.HasFieldError(ctx, fc) {
3736 ec.Errorf(ctx, "must not be null")
3737 }
3738 return graphql.Null
3739 }
3740 res := resTmp.(string)
3741 fc.Result = res
3742 return ec.marshalNString2string(ctx, field.Selections, res)
3743}
3744
3745func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3746 defer func() {
3747 if r := recover(); r != nil {
3748 ec.Error(ctx, ec.Recover(ctx, r))
3749 ret = graphql.Null
3750 }
3751 }()
3752 fc := &graphql.FieldContext{
3753 Object: "AddCommentTimelineItem",
3754 Field: field,
3755 Args: nil,
3756 IsMethod: true,
3757 }
3758
3759 ctx = graphql.WithFieldContext(ctx, fc)
3760 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3761 ctx = rctx // use context from middleware stack in children
3762 return ec.resolvers.AddCommentTimelineItem().Author(rctx, obj)
3763 })
3764 if err != nil {
3765 ec.Error(ctx, err)
3766 return graphql.Null
3767 }
3768 if resTmp == nil {
3769 if !graphql.HasFieldError(ctx, fc) {
3770 ec.Errorf(ctx, "must not be null")
3771 }
3772 return graphql.Null
3773 }
3774 res := resTmp.(models.IdentityWrapper)
3775 fc.Result = res
3776 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3777}
3778
3779func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3780 defer func() {
3781 if r := recover(); r != nil {
3782 ec.Error(ctx, ec.Recover(ctx, r))
3783 ret = graphql.Null
3784 }
3785 }()
3786 fc := &graphql.FieldContext{
3787 Object: "AddCommentTimelineItem",
3788 Field: field,
3789 Args: nil,
3790 IsMethod: false,
3791 }
3792
3793 ctx = graphql.WithFieldContext(ctx, fc)
3794 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3795 ctx = rctx // use context from middleware stack in children
3796 return obj.Message, nil
3797 })
3798 if err != nil {
3799 ec.Error(ctx, err)
3800 return graphql.Null
3801 }
3802 if resTmp == nil {
3803 if !graphql.HasFieldError(ctx, fc) {
3804 ec.Errorf(ctx, "must not be null")
3805 }
3806 return graphql.Null
3807 }
3808 res := resTmp.(string)
3809 fc.Result = res
3810 return ec.marshalNString2string(ctx, field.Selections, res)
3811}
3812
3813func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3814 defer func() {
3815 if r := recover(); r != nil {
3816 ec.Error(ctx, ec.Recover(ctx, r))
3817 ret = graphql.Null
3818 }
3819 }()
3820 fc := &graphql.FieldContext{
3821 Object: "AddCommentTimelineItem",
3822 Field: field,
3823 Args: nil,
3824 IsMethod: true,
3825 }
3826
3827 ctx = graphql.WithFieldContext(ctx, fc)
3828 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3829 ctx = rctx // use context from middleware stack in children
3830 return obj.MessageIsEmpty(), nil
3831 })
3832 if err != nil {
3833 ec.Error(ctx, err)
3834 return graphql.Null
3835 }
3836 if resTmp == nil {
3837 if !graphql.HasFieldError(ctx, fc) {
3838 ec.Errorf(ctx, "must not be null")
3839 }
3840 return graphql.Null
3841 }
3842 res := resTmp.(bool)
3843 fc.Result = res
3844 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3845}
3846
3847func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3848 defer func() {
3849 if r := recover(); r != nil {
3850 ec.Error(ctx, ec.Recover(ctx, r))
3851 ret = graphql.Null
3852 }
3853 }()
3854 fc := &graphql.FieldContext{
3855 Object: "AddCommentTimelineItem",
3856 Field: field,
3857 Args: nil,
3858 IsMethod: false,
3859 }
3860
3861 ctx = graphql.WithFieldContext(ctx, fc)
3862 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3863 ctx = rctx // use context from middleware stack in children
3864 return obj.Files, nil
3865 })
3866 if err != nil {
3867 ec.Error(ctx, err)
3868 return graphql.Null
3869 }
3870 if resTmp == nil {
3871 if !graphql.HasFieldError(ctx, fc) {
3872 ec.Errorf(ctx, "must not be null")
3873 }
3874 return graphql.Null
3875 }
3876 res := resTmp.([]repository.Hash)
3877 fc.Result = res
3878 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
3879}
3880
3881func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3882 defer func() {
3883 if r := recover(); r != nil {
3884 ec.Error(ctx, ec.Recover(ctx, r))
3885 ret = graphql.Null
3886 }
3887 }()
3888 fc := &graphql.FieldContext{
3889 Object: "AddCommentTimelineItem",
3890 Field: field,
3891 Args: nil,
3892 IsMethod: true,
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 ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
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.(*time.Time)
3911 fc.Result = res
3912 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3913}
3914
3915func (ec *executionContext) _AddCommentTimelineItem_lastEdit(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: true,
3927 }
3928
3929 ctx = graphql.WithFieldContext(ctx, fc)
3930 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3931 ctx = rctx // use context from middleware stack in children
3932 return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
3933 })
3934 if err != nil {
3935 ec.Error(ctx, err)
3936 return graphql.Null
3937 }
3938 if resTmp == nil {
3939 if !graphql.HasFieldError(ctx, fc) {
3940 ec.Errorf(ctx, "must not be null")
3941 }
3942 return graphql.Null
3943 }
3944 res := resTmp.(*time.Time)
3945 fc.Result = res
3946 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3947}
3948
3949func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3950 defer func() {
3951 if r := recover(); r != nil {
3952 ec.Error(ctx, ec.Recover(ctx, r))
3953 ret = graphql.Null
3954 }
3955 }()
3956 fc := &graphql.FieldContext{
3957 Object: "AddCommentTimelineItem",
3958 Field: field,
3959 Args: nil,
3960 IsMethod: true,
3961 }
3962
3963 ctx = graphql.WithFieldContext(ctx, fc)
3964 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3965 ctx = rctx // use context from middleware stack in children
3966 return obj.Edited(), nil
3967 })
3968 if err != nil {
3969 ec.Error(ctx, err)
3970 return graphql.Null
3971 }
3972 if resTmp == nil {
3973 if !graphql.HasFieldError(ctx, fc) {
3974 ec.Errorf(ctx, "must not be null")
3975 }
3976 return graphql.Null
3977 }
3978 res := resTmp.(bool)
3979 fc.Result = res
3980 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3981}
3982
3983func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3984 defer func() {
3985 if r := recover(); r != nil {
3986 ec.Error(ctx, ec.Recover(ctx, r))
3987 ret = graphql.Null
3988 }
3989 }()
3990 fc := &graphql.FieldContext{
3991 Object: "AddCommentTimelineItem",
3992 Field: field,
3993 Args: nil,
3994 IsMethod: false,
3995 }
3996
3997 ctx = graphql.WithFieldContext(ctx, fc)
3998 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3999 ctx = rctx // use context from middleware stack in children
4000 return obj.History, nil
4001 })
4002 if err != nil {
4003 ec.Error(ctx, err)
4004 return graphql.Null
4005 }
4006 if resTmp == nil {
4007 if !graphql.HasFieldError(ctx, fc) {
4008 ec.Errorf(ctx, "must not be null")
4009 }
4010 return graphql.Null
4011 }
4012 res := resTmp.([]bug.CommentHistoryStep)
4013 fc.Result = res
4014 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
4015}
4016
4017func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4018 defer func() {
4019 if r := recover(); r != nil {
4020 ec.Error(ctx, ec.Recover(ctx, r))
4021 ret = graphql.Null
4022 }
4023 }()
4024 fc := &graphql.FieldContext{
4025 Object: "Bug",
4026 Field: field,
4027 Args: nil,
4028 IsMethod: true,
4029 }
4030
4031 ctx = graphql.WithFieldContext(ctx, fc)
4032 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4033 ctx = rctx // use context from middleware stack in children
4034 return ec.resolvers.Bug().ID(rctx, obj)
4035 })
4036 if err != nil {
4037 ec.Error(ctx, err)
4038 return graphql.Null
4039 }
4040 if resTmp == nil {
4041 if !graphql.HasFieldError(ctx, fc) {
4042 ec.Errorf(ctx, "must not be null")
4043 }
4044 return graphql.Null
4045 }
4046 res := resTmp.(string)
4047 fc.Result = res
4048 return ec.marshalNString2string(ctx, field.Selections, res)
4049}
4050
4051func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4052 defer func() {
4053 if r := recover(); r != nil {
4054 ec.Error(ctx, ec.Recover(ctx, r))
4055 ret = graphql.Null
4056 }
4057 }()
4058 fc := &graphql.FieldContext{
4059 Object: "Bug",
4060 Field: field,
4061 Args: nil,
4062 IsMethod: true,
4063 }
4064
4065 ctx = graphql.WithFieldContext(ctx, fc)
4066 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4067 ctx = rctx // use context from middleware stack in children
4068 return ec.resolvers.Bug().HumanID(rctx, obj)
4069 })
4070 if err != nil {
4071 ec.Error(ctx, err)
4072 return graphql.Null
4073 }
4074 if resTmp == nil {
4075 if !graphql.HasFieldError(ctx, fc) {
4076 ec.Errorf(ctx, "must not be null")
4077 }
4078 return graphql.Null
4079 }
4080 res := resTmp.(string)
4081 fc.Result = res
4082 return ec.marshalNString2string(ctx, field.Selections, res)
4083}
4084
4085func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4086 defer func() {
4087 if r := recover(); r != nil {
4088 ec.Error(ctx, ec.Recover(ctx, r))
4089 ret = graphql.Null
4090 }
4091 }()
4092 fc := &graphql.FieldContext{
4093 Object: "Bug",
4094 Field: field,
4095 Args: nil,
4096 IsMethod: true,
4097 }
4098
4099 ctx = graphql.WithFieldContext(ctx, fc)
4100 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4101 ctx = rctx // use context from middleware stack in children
4102 return ec.resolvers.Bug().Status(rctx, obj)
4103 })
4104 if err != nil {
4105 ec.Error(ctx, err)
4106 return graphql.Null
4107 }
4108 if resTmp == nil {
4109 if !graphql.HasFieldError(ctx, fc) {
4110 ec.Errorf(ctx, "must not be null")
4111 }
4112 return graphql.Null
4113 }
4114 res := resTmp.(models.Status)
4115 fc.Result = res
4116 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
4117}
4118
4119func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4120 defer func() {
4121 if r := recover(); r != nil {
4122 ec.Error(ctx, ec.Recover(ctx, r))
4123 ret = graphql.Null
4124 }
4125 }()
4126 fc := &graphql.FieldContext{
4127 Object: "Bug",
4128 Field: field,
4129 Args: nil,
4130 IsMethod: true,
4131 }
4132
4133 ctx = graphql.WithFieldContext(ctx, fc)
4134 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4135 ctx = rctx // use context from middleware stack in children
4136 return obj.Title(), nil
4137 })
4138 if err != nil {
4139 ec.Error(ctx, err)
4140 return graphql.Null
4141 }
4142 if resTmp == nil {
4143 if !graphql.HasFieldError(ctx, fc) {
4144 ec.Errorf(ctx, "must not be null")
4145 }
4146 return graphql.Null
4147 }
4148 res := resTmp.(string)
4149 fc.Result = res
4150 return ec.marshalNString2string(ctx, field.Selections, res)
4151}
4152
4153func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4154 defer func() {
4155 if r := recover(); r != nil {
4156 ec.Error(ctx, ec.Recover(ctx, r))
4157 ret = graphql.Null
4158 }
4159 }()
4160 fc := &graphql.FieldContext{
4161 Object: "Bug",
4162 Field: field,
4163 Args: nil,
4164 IsMethod: true,
4165 }
4166
4167 ctx = graphql.WithFieldContext(ctx, fc)
4168 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4169 ctx = rctx // use context from middleware stack in children
4170 return obj.Labels(), nil
4171 })
4172 if err != nil {
4173 ec.Error(ctx, err)
4174 return graphql.Null
4175 }
4176 if resTmp == nil {
4177 if !graphql.HasFieldError(ctx, fc) {
4178 ec.Errorf(ctx, "must not be null")
4179 }
4180 return graphql.Null
4181 }
4182 res := resTmp.([]bug.Label)
4183 fc.Result = res
4184 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
4185}
4186
4187func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4188 defer func() {
4189 if r := recover(); r != nil {
4190 ec.Error(ctx, ec.Recover(ctx, r))
4191 ret = graphql.Null
4192 }
4193 }()
4194 fc := &graphql.FieldContext{
4195 Object: "Bug",
4196 Field: field,
4197 Args: nil,
4198 IsMethod: true,
4199 }
4200
4201 ctx = graphql.WithFieldContext(ctx, fc)
4202 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4203 ctx = rctx // use context from middleware stack in children
4204 return obj.Author()
4205 })
4206 if err != nil {
4207 ec.Error(ctx, err)
4208 return graphql.Null
4209 }
4210 if resTmp == nil {
4211 if !graphql.HasFieldError(ctx, fc) {
4212 ec.Errorf(ctx, "must not be null")
4213 }
4214 return graphql.Null
4215 }
4216 res := resTmp.(models.IdentityWrapper)
4217 fc.Result = res
4218 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
4219}
4220
4221func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4222 defer func() {
4223 if r := recover(); r != nil {
4224 ec.Error(ctx, ec.Recover(ctx, r))
4225 ret = graphql.Null
4226 }
4227 }()
4228 fc := &graphql.FieldContext{
4229 Object: "Bug",
4230 Field: field,
4231 Args: nil,
4232 IsMethod: true,
4233 }
4234
4235 ctx = graphql.WithFieldContext(ctx, fc)
4236 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4237 ctx = rctx // use context from middleware stack in children
4238 return obj.CreatedAt(), nil
4239 })
4240 if err != nil {
4241 ec.Error(ctx, err)
4242 return graphql.Null
4243 }
4244 if resTmp == nil {
4245 if !graphql.HasFieldError(ctx, fc) {
4246 ec.Errorf(ctx, "must not be null")
4247 }
4248 return graphql.Null
4249 }
4250 res := resTmp.(time.Time)
4251 fc.Result = res
4252 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
4253}
4254
4255func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4256 defer func() {
4257 if r := recover(); r != nil {
4258 ec.Error(ctx, ec.Recover(ctx, r))
4259 ret = graphql.Null
4260 }
4261 }()
4262 fc := &graphql.FieldContext{
4263 Object: "Bug",
4264 Field: field,
4265 Args: nil,
4266 IsMethod: true,
4267 }
4268
4269 ctx = graphql.WithFieldContext(ctx, fc)
4270 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4271 ctx = rctx // use context from middleware stack in children
4272 return obj.LastEdit(), nil
4273 })
4274 if err != nil {
4275 ec.Error(ctx, err)
4276 return graphql.Null
4277 }
4278 if resTmp == nil {
4279 if !graphql.HasFieldError(ctx, fc) {
4280 ec.Errorf(ctx, "must not be null")
4281 }
4282 return graphql.Null
4283 }
4284 res := resTmp.(time.Time)
4285 fc.Result = res
4286 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
4287}
4288
4289func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4290 defer func() {
4291 if r := recover(); r != nil {
4292 ec.Error(ctx, ec.Recover(ctx, r))
4293 ret = graphql.Null
4294 }
4295 }()
4296 fc := &graphql.FieldContext{
4297 Object: "Bug",
4298 Field: field,
4299 Args: nil,
4300 IsMethod: true,
4301 }
4302
4303 ctx = graphql.WithFieldContext(ctx, fc)
4304 rawArgs := field.ArgumentMap(ec.Variables)
4305 args, err := ec.field_Bug_actors_args(ctx, rawArgs)
4306 if err != nil {
4307 ec.Error(ctx, err)
4308 return graphql.Null
4309 }
4310 fc.Args = args
4311 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4312 ctx = rctx // use context from middleware stack in children
4313 return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4314 })
4315 if err != nil {
4316 ec.Error(ctx, err)
4317 return graphql.Null
4318 }
4319 if resTmp == nil {
4320 if !graphql.HasFieldError(ctx, fc) {
4321 ec.Errorf(ctx, "must not be null")
4322 }
4323 return graphql.Null
4324 }
4325 res := resTmp.(*models.IdentityConnection)
4326 fc.Result = res
4327 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4328}
4329
4330func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4331 defer func() {
4332 if r := recover(); r != nil {
4333 ec.Error(ctx, ec.Recover(ctx, r))
4334 ret = graphql.Null
4335 }
4336 }()
4337 fc := &graphql.FieldContext{
4338 Object: "Bug",
4339 Field: field,
4340 Args: nil,
4341 IsMethod: true,
4342 }
4343
4344 ctx = graphql.WithFieldContext(ctx, fc)
4345 rawArgs := field.ArgumentMap(ec.Variables)
4346 args, err := ec.field_Bug_participants_args(ctx, rawArgs)
4347 if err != nil {
4348 ec.Error(ctx, err)
4349 return graphql.Null
4350 }
4351 fc.Args = args
4352 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4353 ctx = rctx // use context from middleware stack in children
4354 return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4355 })
4356 if err != nil {
4357 ec.Error(ctx, err)
4358 return graphql.Null
4359 }
4360 if resTmp == nil {
4361 if !graphql.HasFieldError(ctx, fc) {
4362 ec.Errorf(ctx, "must not be null")
4363 }
4364 return graphql.Null
4365 }
4366 res := resTmp.(*models.IdentityConnection)
4367 fc.Result = res
4368 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4369}
4370
4371func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4372 defer func() {
4373 if r := recover(); r != nil {
4374 ec.Error(ctx, ec.Recover(ctx, r))
4375 ret = graphql.Null
4376 }
4377 }()
4378 fc := &graphql.FieldContext{
4379 Object: "Bug",
4380 Field: field,
4381 Args: nil,
4382 IsMethod: true,
4383 }
4384
4385 ctx = graphql.WithFieldContext(ctx, fc)
4386 rawArgs := field.ArgumentMap(ec.Variables)
4387 args, err := ec.field_Bug_comments_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().Comments(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.CommentConnection)
4408 fc.Result = res
4409 return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
4410}
4411
4412func (ec *executionContext) _Bug_timeline(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 }
4425
4426 ctx = graphql.WithFieldContext(ctx, fc)
4427 rawArgs := field.ArgumentMap(ec.Variables)
4428 args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
4429 if err != nil {
4430 ec.Error(ctx, err)
4431 return graphql.Null
4432 }
4433 fc.Args = args
4434 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4435 ctx = rctx // use context from middleware stack in children
4436 return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4437 })
4438 if err != nil {
4439 ec.Error(ctx, err)
4440 return graphql.Null
4441 }
4442 if resTmp == nil {
4443 if !graphql.HasFieldError(ctx, fc) {
4444 ec.Errorf(ctx, "must not be null")
4445 }
4446 return graphql.Null
4447 }
4448 res := resTmp.(*models.TimelineItemConnection)
4449 fc.Result = res
4450 return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
4451}
4452
4453func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4454 defer func() {
4455 if r := recover(); r != nil {
4456 ec.Error(ctx, ec.Recover(ctx, r))
4457 ret = graphql.Null
4458 }
4459 }()
4460 fc := &graphql.FieldContext{
4461 Object: "Bug",
4462 Field: field,
4463 Args: nil,
4464 IsMethod: true,
4465 }
4466
4467 ctx = graphql.WithFieldContext(ctx, fc)
4468 rawArgs := field.ArgumentMap(ec.Variables)
4469 args, err := ec.field_Bug_operations_args(ctx, rawArgs)
4470 if err != nil {
4471 ec.Error(ctx, err)
4472 return graphql.Null
4473 }
4474 fc.Args = args
4475 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4476 ctx = rctx // use context from middleware stack in children
4477 return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4478 })
4479 if err != nil {
4480 ec.Error(ctx, err)
4481 return graphql.Null
4482 }
4483 if resTmp == nil {
4484 if !graphql.HasFieldError(ctx, fc) {
4485 ec.Errorf(ctx, "must not be null")
4486 }
4487 return graphql.Null
4488 }
4489 res := resTmp.(*models.OperationConnection)
4490 fc.Result = res
4491 return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
4492}
4493
4494func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4495 defer func() {
4496 if r := recover(); r != nil {
4497 ec.Error(ctx, ec.Recover(ctx, r))
4498 ret = graphql.Null
4499 }
4500 }()
4501 fc := &graphql.FieldContext{
4502 Object: "BugConnection",
4503 Field: field,
4504 Args: nil,
4505 IsMethod: false,
4506 }
4507
4508 ctx = graphql.WithFieldContext(ctx, fc)
4509 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4510 ctx = rctx // use context from middleware stack in children
4511 return obj.Edges, nil
4512 })
4513 if err != nil {
4514 ec.Error(ctx, err)
4515 return graphql.Null
4516 }
4517 if resTmp == nil {
4518 if !graphql.HasFieldError(ctx, fc) {
4519 ec.Errorf(ctx, "must not be null")
4520 }
4521 return graphql.Null
4522 }
4523 res := resTmp.([]*models.BugEdge)
4524 fc.Result = res
4525 return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
4526}
4527
4528func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4529 defer func() {
4530 if r := recover(); r != nil {
4531 ec.Error(ctx, ec.Recover(ctx, r))
4532 ret = graphql.Null
4533 }
4534 }()
4535 fc := &graphql.FieldContext{
4536 Object: "BugConnection",
4537 Field: field,
4538 Args: nil,
4539 IsMethod: false,
4540 }
4541
4542 ctx = graphql.WithFieldContext(ctx, fc)
4543 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4544 ctx = rctx // use context from middleware stack in children
4545 return obj.Nodes, nil
4546 })
4547 if err != nil {
4548 ec.Error(ctx, err)
4549 return graphql.Null
4550 }
4551 if resTmp == nil {
4552 if !graphql.HasFieldError(ctx, fc) {
4553 ec.Errorf(ctx, "must not be null")
4554 }
4555 return graphql.Null
4556 }
4557 res := resTmp.([]models.BugWrapper)
4558 fc.Result = res
4559 return ec.marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx, field.Selections, res)
4560}
4561
4562func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4563 defer func() {
4564 if r := recover(); r != nil {
4565 ec.Error(ctx, ec.Recover(ctx, r))
4566 ret = graphql.Null
4567 }
4568 }()
4569 fc := &graphql.FieldContext{
4570 Object: "BugConnection",
4571 Field: field,
4572 Args: nil,
4573 IsMethod: false,
4574 }
4575
4576 ctx = graphql.WithFieldContext(ctx, fc)
4577 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4578 ctx = rctx // use context from middleware stack in children
4579 return obj.PageInfo, nil
4580 })
4581 if err != nil {
4582 ec.Error(ctx, err)
4583 return graphql.Null
4584 }
4585 if resTmp == nil {
4586 if !graphql.HasFieldError(ctx, fc) {
4587 ec.Errorf(ctx, "must not be null")
4588 }
4589 return graphql.Null
4590 }
4591 res := resTmp.(*models.PageInfo)
4592 fc.Result = res
4593 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
4594}
4595
4596func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4597 defer func() {
4598 if r := recover(); r != nil {
4599 ec.Error(ctx, ec.Recover(ctx, r))
4600 ret = graphql.Null
4601 }
4602 }()
4603 fc := &graphql.FieldContext{
4604 Object: "BugConnection",
4605 Field: field,
4606 Args: nil,
4607 IsMethod: false,
4608 }
4609
4610 ctx = graphql.WithFieldContext(ctx, fc)
4611 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4612 ctx = rctx // use context from middleware stack in children
4613 return obj.TotalCount, nil
4614 })
4615 if err != nil {
4616 ec.Error(ctx, err)
4617 return graphql.Null
4618 }
4619 if resTmp == nil {
4620 if !graphql.HasFieldError(ctx, fc) {
4621 ec.Errorf(ctx, "must not be null")
4622 }
4623 return graphql.Null
4624 }
4625 res := resTmp.(int)
4626 fc.Result = res
4627 return ec.marshalNInt2int(ctx, field.Selections, res)
4628}
4629
4630func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4631 defer func() {
4632 if r := recover(); r != nil {
4633 ec.Error(ctx, ec.Recover(ctx, r))
4634 ret = graphql.Null
4635 }
4636 }()
4637 fc := &graphql.FieldContext{
4638 Object: "BugEdge",
4639 Field: field,
4640 Args: nil,
4641 IsMethod: false,
4642 }
4643
4644 ctx = graphql.WithFieldContext(ctx, fc)
4645 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4646 ctx = rctx // use context from middleware stack in children
4647 return obj.Cursor, nil
4648 })
4649 if err != nil {
4650 ec.Error(ctx, err)
4651 return graphql.Null
4652 }
4653 if resTmp == nil {
4654 if !graphql.HasFieldError(ctx, fc) {
4655 ec.Errorf(ctx, "must not be null")
4656 }
4657 return graphql.Null
4658 }
4659 res := resTmp.(string)
4660 fc.Result = res
4661 return ec.marshalNString2string(ctx, field.Selections, res)
4662}
4663
4664func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4665 defer func() {
4666 if r := recover(); r != nil {
4667 ec.Error(ctx, ec.Recover(ctx, r))
4668 ret = graphql.Null
4669 }
4670 }()
4671 fc := &graphql.FieldContext{
4672 Object: "BugEdge",
4673 Field: field,
4674 Args: nil,
4675 IsMethod: false,
4676 }
4677
4678 ctx = graphql.WithFieldContext(ctx, fc)
4679 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4680 ctx = rctx // use context from middleware stack in children
4681 return obj.Node, nil
4682 })
4683 if err != nil {
4684 ec.Error(ctx, err)
4685 return graphql.Null
4686 }
4687 if resTmp == nil {
4688 if !graphql.HasFieldError(ctx, fc) {
4689 ec.Errorf(ctx, "must not be null")
4690 }
4691 return graphql.Null
4692 }
4693 res := resTmp.(models.BugWrapper)
4694 fc.Result = res
4695 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4696}
4697
4698func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4699 defer func() {
4700 if r := recover(); r != nil {
4701 ec.Error(ctx, ec.Recover(ctx, r))
4702 ret = graphql.Null
4703 }
4704 }()
4705 fc := &graphql.FieldContext{
4706 Object: "ChangeLabelPayload",
4707 Field: field,
4708 Args: nil,
4709 IsMethod: false,
4710 }
4711
4712 ctx = graphql.WithFieldContext(ctx, fc)
4713 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4714 ctx = rctx // use context from middleware stack in children
4715 return obj.ClientMutationID, nil
4716 })
4717 if err != nil {
4718 ec.Error(ctx, err)
4719 return graphql.Null
4720 }
4721 if resTmp == nil {
4722 return graphql.Null
4723 }
4724 res := resTmp.(*string)
4725 fc.Result = res
4726 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4727}
4728
4729func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4730 defer func() {
4731 if r := recover(); r != nil {
4732 ec.Error(ctx, ec.Recover(ctx, r))
4733 ret = graphql.Null
4734 }
4735 }()
4736 fc := &graphql.FieldContext{
4737 Object: "ChangeLabelPayload",
4738 Field: field,
4739 Args: nil,
4740 IsMethod: false,
4741 }
4742
4743 ctx = graphql.WithFieldContext(ctx, fc)
4744 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4745 ctx = rctx // use context from middleware stack in children
4746 return obj.Bug, nil
4747 })
4748 if err != nil {
4749 ec.Error(ctx, err)
4750 return graphql.Null
4751 }
4752 if resTmp == nil {
4753 if !graphql.HasFieldError(ctx, fc) {
4754 ec.Errorf(ctx, "must not be null")
4755 }
4756 return graphql.Null
4757 }
4758 res := resTmp.(models.BugWrapper)
4759 fc.Result = res
4760 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4761}
4762
4763func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4764 defer func() {
4765 if r := recover(); r != nil {
4766 ec.Error(ctx, ec.Recover(ctx, r))
4767 ret = graphql.Null
4768 }
4769 }()
4770 fc := &graphql.FieldContext{
4771 Object: "ChangeLabelPayload",
4772 Field: field,
4773 Args: nil,
4774 IsMethod: false,
4775 }
4776
4777 ctx = graphql.WithFieldContext(ctx, fc)
4778 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4779 ctx = rctx // use context from middleware stack in children
4780 return obj.Operation, nil
4781 })
4782 if err != nil {
4783 ec.Error(ctx, err)
4784 return graphql.Null
4785 }
4786 if resTmp == nil {
4787 if !graphql.HasFieldError(ctx, fc) {
4788 ec.Errorf(ctx, "must not be null")
4789 }
4790 return graphql.Null
4791 }
4792 res := resTmp.(*bug.LabelChangeOperation)
4793 fc.Result = res
4794 return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
4795}
4796
4797func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4798 defer func() {
4799 if r := recover(); r != nil {
4800 ec.Error(ctx, ec.Recover(ctx, r))
4801 ret = graphql.Null
4802 }
4803 }()
4804 fc := &graphql.FieldContext{
4805 Object: "ChangeLabelPayload",
4806 Field: field,
4807 Args: nil,
4808 IsMethod: false,
4809 }
4810
4811 ctx = graphql.WithFieldContext(ctx, fc)
4812 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4813 ctx = rctx // use context from middleware stack in children
4814 return obj.Results, nil
4815 })
4816 if err != nil {
4817 ec.Error(ctx, err)
4818 return graphql.Null
4819 }
4820 if resTmp == nil {
4821 if !graphql.HasFieldError(ctx, fc) {
4822 ec.Errorf(ctx, "must not be null")
4823 }
4824 return graphql.Null
4825 }
4826 res := resTmp.([]*bug.LabelChangeResult)
4827 fc.Result = res
4828 return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
4829}
4830
4831func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4832 defer func() {
4833 if r := recover(); r != nil {
4834 ec.Error(ctx, ec.Recover(ctx, r))
4835 ret = graphql.Null
4836 }
4837 }()
4838 fc := &graphql.FieldContext{
4839 Object: "CloseBugPayload",
4840 Field: field,
4841 Args: nil,
4842 IsMethod: false,
4843 }
4844
4845 ctx = graphql.WithFieldContext(ctx, fc)
4846 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4847 ctx = rctx // use context from middleware stack in children
4848 return obj.ClientMutationID, nil
4849 })
4850 if err != nil {
4851 ec.Error(ctx, err)
4852 return graphql.Null
4853 }
4854 if resTmp == nil {
4855 return graphql.Null
4856 }
4857 res := resTmp.(*string)
4858 fc.Result = res
4859 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4860}
4861
4862func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4863 defer func() {
4864 if r := recover(); r != nil {
4865 ec.Error(ctx, ec.Recover(ctx, r))
4866 ret = graphql.Null
4867 }
4868 }()
4869 fc := &graphql.FieldContext{
4870 Object: "CloseBugPayload",
4871 Field: field,
4872 Args: nil,
4873 IsMethod: false,
4874 }
4875
4876 ctx = graphql.WithFieldContext(ctx, fc)
4877 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4878 ctx = rctx // use context from middleware stack in children
4879 return obj.Bug, nil
4880 })
4881 if err != nil {
4882 ec.Error(ctx, err)
4883 return graphql.Null
4884 }
4885 if resTmp == nil {
4886 if !graphql.HasFieldError(ctx, fc) {
4887 ec.Errorf(ctx, "must not be null")
4888 }
4889 return graphql.Null
4890 }
4891 res := resTmp.(models.BugWrapper)
4892 fc.Result = res
4893 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4894}
4895
4896func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4897 defer func() {
4898 if r := recover(); r != nil {
4899 ec.Error(ctx, ec.Recover(ctx, r))
4900 ret = graphql.Null
4901 }
4902 }()
4903 fc := &graphql.FieldContext{
4904 Object: "CloseBugPayload",
4905 Field: field,
4906 Args: nil,
4907 IsMethod: false,
4908 }
4909
4910 ctx = graphql.WithFieldContext(ctx, fc)
4911 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4912 ctx = rctx // use context from middleware stack in children
4913 return obj.Operation, nil
4914 })
4915 if err != nil {
4916 ec.Error(ctx, err)
4917 return graphql.Null
4918 }
4919 if resTmp == nil {
4920 if !graphql.HasFieldError(ctx, fc) {
4921 ec.Errorf(ctx, "must not be null")
4922 }
4923 return graphql.Null
4924 }
4925 res := resTmp.(*bug.SetStatusOperation)
4926 fc.Result = res
4927 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
4928}
4929
4930func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4931 defer func() {
4932 if r := recover(); r != nil {
4933 ec.Error(ctx, ec.Recover(ctx, r))
4934 ret = graphql.Null
4935 }
4936 }()
4937 fc := &graphql.FieldContext{
4938 Object: "Color",
4939 Field: field,
4940 Args: nil,
4941 IsMethod: true,
4942 }
4943
4944 ctx = graphql.WithFieldContext(ctx, fc)
4945 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4946 ctx = rctx // use context from middleware stack in children
4947 return ec.resolvers.Color().R(rctx, obj)
4948 })
4949 if err != nil {
4950 ec.Error(ctx, err)
4951 return graphql.Null
4952 }
4953 if resTmp == nil {
4954 if !graphql.HasFieldError(ctx, fc) {
4955 ec.Errorf(ctx, "must not be null")
4956 }
4957 return graphql.Null
4958 }
4959 res := resTmp.(int)
4960 fc.Result = res
4961 return ec.marshalNInt2int(ctx, field.Selections, res)
4962}
4963
4964func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4965 defer func() {
4966 if r := recover(); r != nil {
4967 ec.Error(ctx, ec.Recover(ctx, r))
4968 ret = graphql.Null
4969 }
4970 }()
4971 fc := &graphql.FieldContext{
4972 Object: "Color",
4973 Field: field,
4974 Args: nil,
4975 IsMethod: true,
4976 }
4977
4978 ctx = graphql.WithFieldContext(ctx, fc)
4979 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4980 ctx = rctx // use context from middleware stack in children
4981 return ec.resolvers.Color().G(rctx, obj)
4982 })
4983 if err != nil {
4984 ec.Error(ctx, err)
4985 return graphql.Null
4986 }
4987 if resTmp == nil {
4988 if !graphql.HasFieldError(ctx, fc) {
4989 ec.Errorf(ctx, "must not be null")
4990 }
4991 return graphql.Null
4992 }
4993 res := resTmp.(int)
4994 fc.Result = res
4995 return ec.marshalNInt2int(ctx, field.Selections, res)
4996}
4997
4998func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4999 defer func() {
5000 if r := recover(); r != nil {
5001 ec.Error(ctx, ec.Recover(ctx, r))
5002 ret = graphql.Null
5003 }
5004 }()
5005 fc := &graphql.FieldContext{
5006 Object: "Color",
5007 Field: field,
5008 Args: nil,
5009 IsMethod: true,
5010 }
5011
5012 ctx = graphql.WithFieldContext(ctx, fc)
5013 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5014 ctx = rctx // use context from middleware stack in children
5015 return ec.resolvers.Color().B(rctx, obj)
5016 })
5017 if err != nil {
5018 ec.Error(ctx, err)
5019 return graphql.Null
5020 }
5021 if resTmp == nil {
5022 if !graphql.HasFieldError(ctx, fc) {
5023 ec.Errorf(ctx, "must not be null")
5024 }
5025 return graphql.Null
5026 }
5027 res := resTmp.(int)
5028 fc.Result = res
5029 return ec.marshalNInt2int(ctx, field.Selections, res)
5030}
5031
5032func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
5033 defer func() {
5034 if r := recover(); r != nil {
5035 ec.Error(ctx, ec.Recover(ctx, r))
5036 ret = graphql.Null
5037 }
5038 }()
5039 fc := &graphql.FieldContext{
5040 Object: "Comment",
5041 Field: field,
5042 Args: nil,
5043 IsMethod: true,
5044 }
5045
5046 ctx = graphql.WithFieldContext(ctx, fc)
5047 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5048 ctx = rctx // use context from middleware stack in children
5049 return ec.resolvers.Comment().Author(rctx, obj)
5050 })
5051 if err != nil {
5052 ec.Error(ctx, err)
5053 return graphql.Null
5054 }
5055 if resTmp == nil {
5056 if !graphql.HasFieldError(ctx, fc) {
5057 ec.Errorf(ctx, "must not be null")
5058 }
5059 return graphql.Null
5060 }
5061 res := resTmp.(models.IdentityWrapper)
5062 fc.Result = res
5063 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5064}
5065
5066func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
5067 defer func() {
5068 if r := recover(); r != nil {
5069 ec.Error(ctx, ec.Recover(ctx, r))
5070 ret = graphql.Null
5071 }
5072 }()
5073 fc := &graphql.FieldContext{
5074 Object: "Comment",
5075 Field: field,
5076 Args: nil,
5077 IsMethod: false,
5078 }
5079
5080 ctx = graphql.WithFieldContext(ctx, fc)
5081 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5082 ctx = rctx // use context from middleware stack in children
5083 return obj.Message, nil
5084 })
5085 if err != nil {
5086 ec.Error(ctx, err)
5087 return graphql.Null
5088 }
5089 if resTmp == nil {
5090 if !graphql.HasFieldError(ctx, fc) {
5091 ec.Errorf(ctx, "must not be null")
5092 }
5093 return graphql.Null
5094 }
5095 res := resTmp.(string)
5096 fc.Result = res
5097 return ec.marshalNString2string(ctx, field.Selections, res)
5098}
5099
5100func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
5101 defer func() {
5102 if r := recover(); r != nil {
5103 ec.Error(ctx, ec.Recover(ctx, r))
5104 ret = graphql.Null
5105 }
5106 }()
5107 fc := &graphql.FieldContext{
5108 Object: "Comment",
5109 Field: field,
5110 Args: nil,
5111 IsMethod: false,
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 obj.Files, nil
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.([]repository.Hash)
5130 fc.Result = res
5131 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
5132}
5133
5134func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (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: "CommentConnection",
5143 Field: field,
5144 Args: nil,
5145 IsMethod: false,
5146 }
5147
5148 ctx = graphql.WithFieldContext(ctx, fc)
5149 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5150 ctx = rctx // use context from middleware stack in children
5151 return obj.Edges, nil
5152 })
5153 if err != nil {
5154 ec.Error(ctx, err)
5155 return graphql.Null
5156 }
5157 if resTmp == nil {
5158 if !graphql.HasFieldError(ctx, fc) {
5159 ec.Errorf(ctx, "must not be null")
5160 }
5161 return graphql.Null
5162 }
5163 res := resTmp.([]*models.CommentEdge)
5164 fc.Result = res
5165 return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
5166}
5167
5168func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
5169 defer func() {
5170 if r := recover(); r != nil {
5171 ec.Error(ctx, ec.Recover(ctx, r))
5172 ret = graphql.Null
5173 }
5174 }()
5175 fc := &graphql.FieldContext{
5176 Object: "CommentConnection",
5177 Field: field,
5178 Args: nil,
5179 IsMethod: false,
5180 }
5181
5182 ctx = graphql.WithFieldContext(ctx, fc)
5183 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5184 ctx = rctx // use context from middleware stack in children
5185 return obj.Nodes, nil
5186 })
5187 if err != nil {
5188 ec.Error(ctx, err)
5189 return graphql.Null
5190 }
5191 if resTmp == nil {
5192 if !graphql.HasFieldError(ctx, fc) {
5193 ec.Errorf(ctx, "must not be null")
5194 }
5195 return graphql.Null
5196 }
5197 res := resTmp.([]*bug.Comment)
5198 fc.Result = res
5199 return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx, field.Selections, res)
5200}
5201
5202func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
5203 defer func() {
5204 if r := recover(); r != nil {
5205 ec.Error(ctx, ec.Recover(ctx, r))
5206 ret = graphql.Null
5207 }
5208 }()
5209 fc := &graphql.FieldContext{
5210 Object: "CommentConnection",
5211 Field: field,
5212 Args: nil,
5213 IsMethod: false,
5214 }
5215
5216 ctx = graphql.WithFieldContext(ctx, fc)
5217 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5218 ctx = rctx // use context from middleware stack in children
5219 return obj.PageInfo, nil
5220 })
5221 if err != nil {
5222 ec.Error(ctx, err)
5223 return graphql.Null
5224 }
5225 if resTmp == nil {
5226 if !graphql.HasFieldError(ctx, fc) {
5227 ec.Errorf(ctx, "must not be null")
5228 }
5229 return graphql.Null
5230 }
5231 res := resTmp.(*models.PageInfo)
5232 fc.Result = res
5233 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
5234}
5235
5236func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
5237 defer func() {
5238 if r := recover(); r != nil {
5239 ec.Error(ctx, ec.Recover(ctx, r))
5240 ret = graphql.Null
5241 }
5242 }()
5243 fc := &graphql.FieldContext{
5244 Object: "CommentConnection",
5245 Field: field,
5246 Args: nil,
5247 IsMethod: false,
5248 }
5249
5250 ctx = graphql.WithFieldContext(ctx, fc)
5251 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5252 ctx = rctx // use context from middleware stack in children
5253 return obj.TotalCount, nil
5254 })
5255 if err != nil {
5256 ec.Error(ctx, err)
5257 return graphql.Null
5258 }
5259 if resTmp == nil {
5260 if !graphql.HasFieldError(ctx, fc) {
5261 ec.Errorf(ctx, "must not be null")
5262 }
5263 return graphql.Null
5264 }
5265 res := resTmp.(int)
5266 fc.Result = res
5267 return ec.marshalNInt2int(ctx, field.Selections, res)
5268}
5269
5270func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
5271 defer func() {
5272 if r := recover(); r != nil {
5273 ec.Error(ctx, ec.Recover(ctx, r))
5274 ret = graphql.Null
5275 }
5276 }()
5277 fc := &graphql.FieldContext{
5278 Object: "CommentEdge",
5279 Field: field,
5280 Args: nil,
5281 IsMethod: false,
5282 }
5283
5284 ctx = graphql.WithFieldContext(ctx, fc)
5285 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5286 ctx = rctx // use context from middleware stack in children
5287 return obj.Cursor, nil
5288 })
5289 if err != nil {
5290 ec.Error(ctx, err)
5291 return graphql.Null
5292 }
5293 if resTmp == nil {
5294 if !graphql.HasFieldError(ctx, fc) {
5295 ec.Errorf(ctx, "must not be null")
5296 }
5297 return graphql.Null
5298 }
5299 res := resTmp.(string)
5300 fc.Result = res
5301 return ec.marshalNString2string(ctx, field.Selections, res)
5302}
5303
5304func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
5305 defer func() {
5306 if r := recover(); r != nil {
5307 ec.Error(ctx, ec.Recover(ctx, r))
5308 ret = graphql.Null
5309 }
5310 }()
5311 fc := &graphql.FieldContext{
5312 Object: "CommentEdge",
5313 Field: field,
5314 Args: nil,
5315 IsMethod: false,
5316 }
5317
5318 ctx = graphql.WithFieldContext(ctx, fc)
5319 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5320 ctx = rctx // use context from middleware stack in children
5321 return obj.Node, nil
5322 })
5323 if err != nil {
5324 ec.Error(ctx, err)
5325 return graphql.Null
5326 }
5327 if resTmp == nil {
5328 if !graphql.HasFieldError(ctx, fc) {
5329 ec.Errorf(ctx, "must not be null")
5330 }
5331 return graphql.Null
5332 }
5333 res := resTmp.(*bug.Comment)
5334 fc.Result = res
5335 return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
5336}
5337
5338func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
5339 defer func() {
5340 if r := recover(); r != nil {
5341 ec.Error(ctx, ec.Recover(ctx, r))
5342 ret = graphql.Null
5343 }
5344 }()
5345 fc := &graphql.FieldContext{
5346 Object: "CommentHistoryStep",
5347 Field: field,
5348 Args: nil,
5349 IsMethod: false,
5350 }
5351
5352 ctx = graphql.WithFieldContext(ctx, fc)
5353 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5354 ctx = rctx // use context from middleware stack in children
5355 return obj.Message, nil
5356 })
5357 if err != nil {
5358 ec.Error(ctx, err)
5359 return graphql.Null
5360 }
5361 if resTmp == nil {
5362 if !graphql.HasFieldError(ctx, fc) {
5363 ec.Errorf(ctx, "must not be null")
5364 }
5365 return graphql.Null
5366 }
5367 res := resTmp.(string)
5368 fc.Result = res
5369 return ec.marshalNString2string(ctx, field.Selections, res)
5370}
5371
5372func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
5373 defer func() {
5374 if r := recover(); r != nil {
5375 ec.Error(ctx, ec.Recover(ctx, r))
5376 ret = graphql.Null
5377 }
5378 }()
5379 fc := &graphql.FieldContext{
5380 Object: "CommentHistoryStep",
5381 Field: field,
5382 Args: nil,
5383 IsMethod: true,
5384 }
5385
5386 ctx = graphql.WithFieldContext(ctx, fc)
5387 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5388 ctx = rctx // use context from middleware stack in children
5389 return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
5390 })
5391 if err != nil {
5392 ec.Error(ctx, err)
5393 return graphql.Null
5394 }
5395 if resTmp == nil {
5396 if !graphql.HasFieldError(ctx, fc) {
5397 ec.Errorf(ctx, "must not be null")
5398 }
5399 return graphql.Null
5400 }
5401 res := resTmp.(*time.Time)
5402 fc.Result = res
5403 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5404}
5405
5406func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5407 defer func() {
5408 if r := recover(); r != nil {
5409 ec.Error(ctx, ec.Recover(ctx, r))
5410 ret = graphql.Null
5411 }
5412 }()
5413 fc := &graphql.FieldContext{
5414 Object: "CreateOperation",
5415 Field: field,
5416 Args: nil,
5417 IsMethod: true,
5418 }
5419
5420 ctx = graphql.WithFieldContext(ctx, fc)
5421 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5422 ctx = rctx // use context from middleware stack in children
5423 return ec.resolvers.CreateOperation().ID(rctx, obj)
5424 })
5425 if err != nil {
5426 ec.Error(ctx, err)
5427 return graphql.Null
5428 }
5429 if resTmp == nil {
5430 if !graphql.HasFieldError(ctx, fc) {
5431 ec.Errorf(ctx, "must not be null")
5432 }
5433 return graphql.Null
5434 }
5435 res := resTmp.(string)
5436 fc.Result = res
5437 return ec.marshalNString2string(ctx, field.Selections, res)
5438}
5439
5440func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5441 defer func() {
5442 if r := recover(); r != nil {
5443 ec.Error(ctx, ec.Recover(ctx, r))
5444 ret = graphql.Null
5445 }
5446 }()
5447 fc := &graphql.FieldContext{
5448 Object: "CreateOperation",
5449 Field: field,
5450 Args: nil,
5451 IsMethod: true,
5452 }
5453
5454 ctx = graphql.WithFieldContext(ctx, fc)
5455 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5456 ctx = rctx // use context from middleware stack in children
5457 return ec.resolvers.CreateOperation().Author(rctx, obj)
5458 })
5459 if err != nil {
5460 ec.Error(ctx, err)
5461 return graphql.Null
5462 }
5463 if resTmp == nil {
5464 if !graphql.HasFieldError(ctx, fc) {
5465 ec.Errorf(ctx, "must not be null")
5466 }
5467 return graphql.Null
5468 }
5469 res := resTmp.(models.IdentityWrapper)
5470 fc.Result = res
5471 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5472}
5473
5474func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5475 defer func() {
5476 if r := recover(); r != nil {
5477 ec.Error(ctx, ec.Recover(ctx, r))
5478 ret = graphql.Null
5479 }
5480 }()
5481 fc := &graphql.FieldContext{
5482 Object: "CreateOperation",
5483 Field: field,
5484 Args: nil,
5485 IsMethod: true,
5486 }
5487
5488 ctx = graphql.WithFieldContext(ctx, fc)
5489 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5490 ctx = rctx // use context from middleware stack in children
5491 return ec.resolvers.CreateOperation().Date(rctx, obj)
5492 })
5493 if err != nil {
5494 ec.Error(ctx, err)
5495 return graphql.Null
5496 }
5497 if resTmp == nil {
5498 if !graphql.HasFieldError(ctx, fc) {
5499 ec.Errorf(ctx, "must not be null")
5500 }
5501 return graphql.Null
5502 }
5503 res := resTmp.(*time.Time)
5504 fc.Result = res
5505 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5506}
5507
5508func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5509 defer func() {
5510 if r := recover(); r != nil {
5511 ec.Error(ctx, ec.Recover(ctx, r))
5512 ret = graphql.Null
5513 }
5514 }()
5515 fc := &graphql.FieldContext{
5516 Object: "CreateOperation",
5517 Field: field,
5518 Args: nil,
5519 IsMethod: false,
5520 }
5521
5522 ctx = graphql.WithFieldContext(ctx, fc)
5523 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5524 ctx = rctx // use context from middleware stack in children
5525 return obj.Title, nil
5526 })
5527 if err != nil {
5528 ec.Error(ctx, err)
5529 return graphql.Null
5530 }
5531 if resTmp == nil {
5532 if !graphql.HasFieldError(ctx, fc) {
5533 ec.Errorf(ctx, "must not be null")
5534 }
5535 return graphql.Null
5536 }
5537 res := resTmp.(string)
5538 fc.Result = res
5539 return ec.marshalNString2string(ctx, field.Selections, res)
5540}
5541
5542func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5543 defer func() {
5544 if r := recover(); r != nil {
5545 ec.Error(ctx, ec.Recover(ctx, r))
5546 ret = graphql.Null
5547 }
5548 }()
5549 fc := &graphql.FieldContext{
5550 Object: "CreateOperation",
5551 Field: field,
5552 Args: nil,
5553 IsMethod: false,
5554 }
5555
5556 ctx = graphql.WithFieldContext(ctx, fc)
5557 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5558 ctx = rctx // use context from middleware stack in children
5559 return obj.Message, nil
5560 })
5561 if err != nil {
5562 ec.Error(ctx, err)
5563 return graphql.Null
5564 }
5565 if resTmp == nil {
5566 if !graphql.HasFieldError(ctx, fc) {
5567 ec.Errorf(ctx, "must not be null")
5568 }
5569 return graphql.Null
5570 }
5571 res := resTmp.(string)
5572 fc.Result = res
5573 return ec.marshalNString2string(ctx, field.Selections, res)
5574}
5575
5576func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5577 defer func() {
5578 if r := recover(); r != nil {
5579 ec.Error(ctx, ec.Recover(ctx, r))
5580 ret = graphql.Null
5581 }
5582 }()
5583 fc := &graphql.FieldContext{
5584 Object: "CreateOperation",
5585 Field: field,
5586 Args: nil,
5587 IsMethod: false,
5588 }
5589
5590 ctx = graphql.WithFieldContext(ctx, fc)
5591 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5592 ctx = rctx // use context from middleware stack in children
5593 return obj.Files, nil
5594 })
5595 if err != nil {
5596 ec.Error(ctx, err)
5597 return graphql.Null
5598 }
5599 if resTmp == nil {
5600 if !graphql.HasFieldError(ctx, fc) {
5601 ec.Errorf(ctx, "must not be null")
5602 }
5603 return graphql.Null
5604 }
5605 res := resTmp.([]repository.Hash)
5606 fc.Result = res
5607 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
5608}
5609
5610func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5611 defer func() {
5612 if r := recover(); r != nil {
5613 ec.Error(ctx, ec.Recover(ctx, r))
5614 ret = graphql.Null
5615 }
5616 }()
5617 fc := &graphql.FieldContext{
5618 Object: "CreateTimelineItem",
5619 Field: field,
5620 Args: nil,
5621 IsMethod: true,
5622 }
5623
5624 ctx = graphql.WithFieldContext(ctx, fc)
5625 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5626 ctx = rctx // use context from middleware stack in children
5627 return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
5628 })
5629 if err != nil {
5630 ec.Error(ctx, err)
5631 return graphql.Null
5632 }
5633 if resTmp == nil {
5634 if !graphql.HasFieldError(ctx, fc) {
5635 ec.Errorf(ctx, "must not be null")
5636 }
5637 return graphql.Null
5638 }
5639 res := resTmp.(string)
5640 fc.Result = res
5641 return ec.marshalNString2string(ctx, field.Selections, res)
5642}
5643
5644func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5645 defer func() {
5646 if r := recover(); r != nil {
5647 ec.Error(ctx, ec.Recover(ctx, r))
5648 ret = graphql.Null
5649 }
5650 }()
5651 fc := &graphql.FieldContext{
5652 Object: "CreateTimelineItem",
5653 Field: field,
5654 Args: nil,
5655 IsMethod: true,
5656 }
5657
5658 ctx = graphql.WithFieldContext(ctx, fc)
5659 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5660 ctx = rctx // use context from middleware stack in children
5661 return ec.resolvers.CreateTimelineItem().Author(rctx, obj)
5662 })
5663 if err != nil {
5664 ec.Error(ctx, err)
5665 return graphql.Null
5666 }
5667 if resTmp == nil {
5668 if !graphql.HasFieldError(ctx, fc) {
5669 ec.Errorf(ctx, "must not be null")
5670 }
5671 return graphql.Null
5672 }
5673 res := resTmp.(models.IdentityWrapper)
5674 fc.Result = res
5675 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5676}
5677
5678func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5679 defer func() {
5680 if r := recover(); r != nil {
5681 ec.Error(ctx, ec.Recover(ctx, r))
5682 ret = graphql.Null
5683 }
5684 }()
5685 fc := &graphql.FieldContext{
5686 Object: "CreateTimelineItem",
5687 Field: field,
5688 Args: nil,
5689 IsMethod: false,
5690 }
5691
5692 ctx = graphql.WithFieldContext(ctx, fc)
5693 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5694 ctx = rctx // use context from middleware stack in children
5695 return obj.Message, nil
5696 })
5697 if err != nil {
5698 ec.Error(ctx, err)
5699 return graphql.Null
5700 }
5701 if resTmp == nil {
5702 if !graphql.HasFieldError(ctx, fc) {
5703 ec.Errorf(ctx, "must not be null")
5704 }
5705 return graphql.Null
5706 }
5707 res := resTmp.(string)
5708 fc.Result = res
5709 return ec.marshalNString2string(ctx, field.Selections, res)
5710}
5711
5712func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5713 defer func() {
5714 if r := recover(); r != nil {
5715 ec.Error(ctx, ec.Recover(ctx, r))
5716 ret = graphql.Null
5717 }
5718 }()
5719 fc := &graphql.FieldContext{
5720 Object: "CreateTimelineItem",
5721 Field: field,
5722 Args: nil,
5723 IsMethod: true,
5724 }
5725
5726 ctx = graphql.WithFieldContext(ctx, fc)
5727 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5728 ctx = rctx // use context from middleware stack in children
5729 return obj.MessageIsEmpty(), nil
5730 })
5731 if err != nil {
5732 ec.Error(ctx, err)
5733 return graphql.Null
5734 }
5735 if resTmp == nil {
5736 if !graphql.HasFieldError(ctx, fc) {
5737 ec.Errorf(ctx, "must not be null")
5738 }
5739 return graphql.Null
5740 }
5741 res := resTmp.(bool)
5742 fc.Result = res
5743 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5744}
5745
5746func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5747 defer func() {
5748 if r := recover(); r != nil {
5749 ec.Error(ctx, ec.Recover(ctx, r))
5750 ret = graphql.Null
5751 }
5752 }()
5753 fc := &graphql.FieldContext{
5754 Object: "CreateTimelineItem",
5755 Field: field,
5756 Args: nil,
5757 IsMethod: false,
5758 }
5759
5760 ctx = graphql.WithFieldContext(ctx, fc)
5761 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5762 ctx = rctx // use context from middleware stack in children
5763 return obj.Files, nil
5764 })
5765 if err != nil {
5766 ec.Error(ctx, err)
5767 return graphql.Null
5768 }
5769 if resTmp == nil {
5770 if !graphql.HasFieldError(ctx, fc) {
5771 ec.Errorf(ctx, "must not be null")
5772 }
5773 return graphql.Null
5774 }
5775 res := resTmp.([]repository.Hash)
5776 fc.Result = res
5777 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
5778}
5779
5780func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5781 defer func() {
5782 if r := recover(); r != nil {
5783 ec.Error(ctx, ec.Recover(ctx, r))
5784 ret = graphql.Null
5785 }
5786 }()
5787 fc := &graphql.FieldContext{
5788 Object: "CreateTimelineItem",
5789 Field: field,
5790 Args: nil,
5791 IsMethod: true,
5792 }
5793
5794 ctx = graphql.WithFieldContext(ctx, fc)
5795 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5796 ctx = rctx // use context from middleware stack in children
5797 return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
5798 })
5799 if err != nil {
5800 ec.Error(ctx, err)
5801 return graphql.Null
5802 }
5803 if resTmp == nil {
5804 if !graphql.HasFieldError(ctx, fc) {
5805 ec.Errorf(ctx, "must not be null")
5806 }
5807 return graphql.Null
5808 }
5809 res := resTmp.(*time.Time)
5810 fc.Result = res
5811 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5812}
5813
5814func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5815 defer func() {
5816 if r := recover(); r != nil {
5817 ec.Error(ctx, ec.Recover(ctx, r))
5818 ret = graphql.Null
5819 }
5820 }()
5821 fc := &graphql.FieldContext{
5822 Object: "CreateTimelineItem",
5823 Field: field,
5824 Args: nil,
5825 IsMethod: true,
5826 }
5827
5828 ctx = graphql.WithFieldContext(ctx, fc)
5829 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5830 ctx = rctx // use context from middleware stack in children
5831 return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
5832 })
5833 if err != nil {
5834 ec.Error(ctx, err)
5835 return graphql.Null
5836 }
5837 if resTmp == nil {
5838 if !graphql.HasFieldError(ctx, fc) {
5839 ec.Errorf(ctx, "must not be null")
5840 }
5841 return graphql.Null
5842 }
5843 res := resTmp.(*time.Time)
5844 fc.Result = res
5845 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5846}
5847
5848func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5849 defer func() {
5850 if r := recover(); r != nil {
5851 ec.Error(ctx, ec.Recover(ctx, r))
5852 ret = graphql.Null
5853 }
5854 }()
5855 fc := &graphql.FieldContext{
5856 Object: "CreateTimelineItem",
5857 Field: field,
5858 Args: nil,
5859 IsMethod: true,
5860 }
5861
5862 ctx = graphql.WithFieldContext(ctx, fc)
5863 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5864 ctx = rctx // use context from middleware stack in children
5865 return obj.Edited(), nil
5866 })
5867 if err != nil {
5868 ec.Error(ctx, err)
5869 return graphql.Null
5870 }
5871 if resTmp == nil {
5872 if !graphql.HasFieldError(ctx, fc) {
5873 ec.Errorf(ctx, "must not be null")
5874 }
5875 return graphql.Null
5876 }
5877 res := resTmp.(bool)
5878 fc.Result = res
5879 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5880}
5881
5882func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5883 defer func() {
5884 if r := recover(); r != nil {
5885 ec.Error(ctx, ec.Recover(ctx, r))
5886 ret = graphql.Null
5887 }
5888 }()
5889 fc := &graphql.FieldContext{
5890 Object: "CreateTimelineItem",
5891 Field: field,
5892 Args: nil,
5893 IsMethod: false,
5894 }
5895
5896 ctx = graphql.WithFieldContext(ctx, fc)
5897 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5898 ctx = rctx // use context from middleware stack in children
5899 return obj.History, nil
5900 })
5901 if err != nil {
5902 ec.Error(ctx, err)
5903 return graphql.Null
5904 }
5905 if resTmp == nil {
5906 if !graphql.HasFieldError(ctx, fc) {
5907 ec.Errorf(ctx, "must not be null")
5908 }
5909 return graphql.Null
5910 }
5911 res := resTmp.([]bug.CommentHistoryStep)
5912 fc.Result = res
5913 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
5914}
5915
5916func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5917 defer func() {
5918 if r := recover(); r != nil {
5919 ec.Error(ctx, ec.Recover(ctx, r))
5920 ret = graphql.Null
5921 }
5922 }()
5923 fc := &graphql.FieldContext{
5924 Object: "EditCommentOperation",
5925 Field: field,
5926 Args: nil,
5927 IsMethod: true,
5928 }
5929
5930 ctx = graphql.WithFieldContext(ctx, fc)
5931 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5932 ctx = rctx // use context from middleware stack in children
5933 return ec.resolvers.EditCommentOperation().ID(rctx, obj)
5934 })
5935 if err != nil {
5936 ec.Error(ctx, err)
5937 return graphql.Null
5938 }
5939 if resTmp == nil {
5940 if !graphql.HasFieldError(ctx, fc) {
5941 ec.Errorf(ctx, "must not be null")
5942 }
5943 return graphql.Null
5944 }
5945 res := resTmp.(string)
5946 fc.Result = res
5947 return ec.marshalNString2string(ctx, field.Selections, res)
5948}
5949
5950func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5951 defer func() {
5952 if r := recover(); r != nil {
5953 ec.Error(ctx, ec.Recover(ctx, r))
5954 ret = graphql.Null
5955 }
5956 }()
5957 fc := &graphql.FieldContext{
5958 Object: "EditCommentOperation",
5959 Field: field,
5960 Args: nil,
5961 IsMethod: true,
5962 }
5963
5964 ctx = graphql.WithFieldContext(ctx, fc)
5965 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5966 ctx = rctx // use context from middleware stack in children
5967 return ec.resolvers.EditCommentOperation().Author(rctx, obj)
5968 })
5969 if err != nil {
5970 ec.Error(ctx, err)
5971 return graphql.Null
5972 }
5973 if resTmp == nil {
5974 if !graphql.HasFieldError(ctx, fc) {
5975 ec.Errorf(ctx, "must not be null")
5976 }
5977 return graphql.Null
5978 }
5979 res := resTmp.(models.IdentityWrapper)
5980 fc.Result = res
5981 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5982}
5983
5984func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5985 defer func() {
5986 if r := recover(); r != nil {
5987 ec.Error(ctx, ec.Recover(ctx, r))
5988 ret = graphql.Null
5989 }
5990 }()
5991 fc := &graphql.FieldContext{
5992 Object: "EditCommentOperation",
5993 Field: field,
5994 Args: nil,
5995 IsMethod: true,
5996 }
5997
5998 ctx = graphql.WithFieldContext(ctx, fc)
5999 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6000 ctx = rctx // use context from middleware stack in children
6001 return ec.resolvers.EditCommentOperation().Date(rctx, obj)
6002 })
6003 if err != nil {
6004 ec.Error(ctx, err)
6005 return graphql.Null
6006 }
6007 if resTmp == nil {
6008 if !graphql.HasFieldError(ctx, fc) {
6009 ec.Errorf(ctx, "must not be null")
6010 }
6011 return graphql.Null
6012 }
6013 res := resTmp.(*time.Time)
6014 fc.Result = res
6015 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6016}
6017
6018func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
6019 defer func() {
6020 if r := recover(); r != nil {
6021 ec.Error(ctx, ec.Recover(ctx, r))
6022 ret = graphql.Null
6023 }
6024 }()
6025 fc := &graphql.FieldContext{
6026 Object: "EditCommentOperation",
6027 Field: field,
6028 Args: nil,
6029 IsMethod: true,
6030 }
6031
6032 ctx = graphql.WithFieldContext(ctx, fc)
6033 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6034 ctx = rctx // use context from middleware stack in children
6035 return ec.resolvers.EditCommentOperation().Target(rctx, obj)
6036 })
6037 if err != nil {
6038 ec.Error(ctx, err)
6039 return graphql.Null
6040 }
6041 if resTmp == nil {
6042 if !graphql.HasFieldError(ctx, fc) {
6043 ec.Errorf(ctx, "must not be null")
6044 }
6045 return graphql.Null
6046 }
6047 res := resTmp.(string)
6048 fc.Result = res
6049 return ec.marshalNString2string(ctx, field.Selections, res)
6050}
6051
6052func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
6053 defer func() {
6054 if r := recover(); r != nil {
6055 ec.Error(ctx, ec.Recover(ctx, r))
6056 ret = graphql.Null
6057 }
6058 }()
6059 fc := &graphql.FieldContext{
6060 Object: "EditCommentOperation",
6061 Field: field,
6062 Args: nil,
6063 IsMethod: false,
6064 }
6065
6066 ctx = graphql.WithFieldContext(ctx, fc)
6067 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6068 ctx = rctx // use context from middleware stack in children
6069 return obj.Message, nil
6070 })
6071 if err != nil {
6072 ec.Error(ctx, err)
6073 return graphql.Null
6074 }
6075 if resTmp == nil {
6076 if !graphql.HasFieldError(ctx, fc) {
6077 ec.Errorf(ctx, "must not be null")
6078 }
6079 return graphql.Null
6080 }
6081 res := resTmp.(string)
6082 fc.Result = res
6083 return ec.marshalNString2string(ctx, field.Selections, res)
6084}
6085
6086func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
6087 defer func() {
6088 if r := recover(); r != nil {
6089 ec.Error(ctx, ec.Recover(ctx, r))
6090 ret = graphql.Null
6091 }
6092 }()
6093 fc := &graphql.FieldContext{
6094 Object: "EditCommentOperation",
6095 Field: field,
6096 Args: nil,
6097 IsMethod: false,
6098 }
6099
6100 ctx = graphql.WithFieldContext(ctx, fc)
6101 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6102 ctx = rctx // use context from middleware stack in children
6103 return obj.Files, nil
6104 })
6105 if err != nil {
6106 ec.Error(ctx, err)
6107 return graphql.Null
6108 }
6109 if resTmp == nil {
6110 if !graphql.HasFieldError(ctx, fc) {
6111 ec.Errorf(ctx, "must not be null")
6112 }
6113 return graphql.Null
6114 }
6115 res := resTmp.([]repository.Hash)
6116 fc.Result = res
6117 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
6118}
6119
6120func (ec *executionContext) _EditCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
6121 defer func() {
6122 if r := recover(); r != nil {
6123 ec.Error(ctx, ec.Recover(ctx, r))
6124 ret = graphql.Null
6125 }
6126 }()
6127 fc := &graphql.FieldContext{
6128 Object: "EditCommentPayload",
6129 Field: field,
6130 Args: nil,
6131 IsMethod: false,
6132 }
6133
6134 ctx = graphql.WithFieldContext(ctx, fc)
6135 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6136 ctx = rctx // use context from middleware stack in children
6137 return obj.ClientMutationID, nil
6138 })
6139 if err != nil {
6140 ec.Error(ctx, err)
6141 return graphql.Null
6142 }
6143 if resTmp == nil {
6144 return graphql.Null
6145 }
6146 res := resTmp.(*string)
6147 fc.Result = res
6148 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
6149}
6150
6151func (ec *executionContext) _EditCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
6152 defer func() {
6153 if r := recover(); r != nil {
6154 ec.Error(ctx, ec.Recover(ctx, r))
6155 ret = graphql.Null
6156 }
6157 }()
6158 fc := &graphql.FieldContext{
6159 Object: "EditCommentPayload",
6160 Field: field,
6161 Args: nil,
6162 IsMethod: false,
6163 }
6164
6165 ctx = graphql.WithFieldContext(ctx, fc)
6166 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6167 ctx = rctx // use context from middleware stack in children
6168 return obj.Bug, nil
6169 })
6170 if err != nil {
6171 ec.Error(ctx, err)
6172 return graphql.Null
6173 }
6174 if resTmp == nil {
6175 if !graphql.HasFieldError(ctx, fc) {
6176 ec.Errorf(ctx, "must not be null")
6177 }
6178 return graphql.Null
6179 }
6180 res := resTmp.(models.BugWrapper)
6181 fc.Result = res
6182 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
6183}
6184
6185func (ec *executionContext) _EditCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
6186 defer func() {
6187 if r := recover(); r != nil {
6188 ec.Error(ctx, ec.Recover(ctx, r))
6189 ret = graphql.Null
6190 }
6191 }()
6192 fc := &graphql.FieldContext{
6193 Object: "EditCommentPayload",
6194 Field: field,
6195 Args: nil,
6196 IsMethod: 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.Operation, 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.(*bug.EditCommentOperation)
6215 fc.Result = res
6216 return ec.marshalNEditCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐEditCommentOperation(ctx, field.Selections, res)
6217}
6218
6219func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (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: "Identity",
6228 Field: field,
6229 Args: nil,
6230 IsMethod: true,
6231 }
6232
6233 ctx = graphql.WithFieldContext(ctx, fc)
6234 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6235 ctx = rctx // use context from middleware stack in children
6236 return ec.resolvers.Identity().ID(rctx, obj)
6237 })
6238 if err != nil {
6239 ec.Error(ctx, err)
6240 return graphql.Null
6241 }
6242 if resTmp == nil {
6243 if !graphql.HasFieldError(ctx, fc) {
6244 ec.Errorf(ctx, "must not be null")
6245 }
6246 return graphql.Null
6247 }
6248 res := resTmp.(string)
6249 fc.Result = res
6250 return ec.marshalNString2string(ctx, field.Selections, res)
6251}
6252
6253func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6254 defer func() {
6255 if r := recover(); r != nil {
6256 ec.Error(ctx, ec.Recover(ctx, r))
6257 ret = graphql.Null
6258 }
6259 }()
6260 fc := &graphql.FieldContext{
6261 Object: "Identity",
6262 Field: field,
6263 Args: nil,
6264 IsMethod: true,
6265 }
6266
6267 ctx = graphql.WithFieldContext(ctx, fc)
6268 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6269 ctx = rctx // use context from middleware stack in children
6270 return ec.resolvers.Identity().HumanID(rctx, obj)
6271 })
6272 if err != nil {
6273 ec.Error(ctx, err)
6274 return graphql.Null
6275 }
6276 if resTmp == nil {
6277 if !graphql.HasFieldError(ctx, fc) {
6278 ec.Errorf(ctx, "must not be null")
6279 }
6280 return graphql.Null
6281 }
6282 res := resTmp.(string)
6283 fc.Result = res
6284 return ec.marshalNString2string(ctx, field.Selections, res)
6285}
6286
6287func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6288 defer func() {
6289 if r := recover(); r != nil {
6290 ec.Error(ctx, ec.Recover(ctx, r))
6291 ret = graphql.Null
6292 }
6293 }()
6294 fc := &graphql.FieldContext{
6295 Object: "Identity",
6296 Field: field,
6297 Args: nil,
6298 IsMethod: true,
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.Name(), nil
6305 })
6306 if err != nil {
6307 ec.Error(ctx, err)
6308 return graphql.Null
6309 }
6310 if resTmp == nil {
6311 return graphql.Null
6312 }
6313 res := resTmp.(string)
6314 fc.Result = res
6315 return ec.marshalOString2string(ctx, field.Selections, res)
6316}
6317
6318func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6319 defer func() {
6320 if r := recover(); r != nil {
6321 ec.Error(ctx, ec.Recover(ctx, r))
6322 ret = graphql.Null
6323 }
6324 }()
6325 fc := &graphql.FieldContext{
6326 Object: "Identity",
6327 Field: field,
6328 Args: nil,
6329 IsMethod: true,
6330 }
6331
6332 ctx = graphql.WithFieldContext(ctx, fc)
6333 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6334 ctx = rctx // use context from middleware stack in children
6335 return obj.Email()
6336 })
6337 if err != nil {
6338 ec.Error(ctx, err)
6339 return graphql.Null
6340 }
6341 if resTmp == nil {
6342 return graphql.Null
6343 }
6344 res := resTmp.(string)
6345 fc.Result = res
6346 return ec.marshalOString2string(ctx, field.Selections, res)
6347}
6348
6349func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6350 defer func() {
6351 if r := recover(); r != nil {
6352 ec.Error(ctx, ec.Recover(ctx, r))
6353 ret = graphql.Null
6354 }
6355 }()
6356 fc := &graphql.FieldContext{
6357 Object: "Identity",
6358 Field: field,
6359 Args: nil,
6360 IsMethod: true,
6361 }
6362
6363 ctx = graphql.WithFieldContext(ctx, fc)
6364 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6365 ctx = rctx // use context from middleware stack in children
6366 return obj.Login()
6367 })
6368 if err != nil {
6369 ec.Error(ctx, err)
6370 return graphql.Null
6371 }
6372 if resTmp == nil {
6373 return graphql.Null
6374 }
6375 res := resTmp.(string)
6376 fc.Result = res
6377 return ec.marshalOString2string(ctx, field.Selections, res)
6378}
6379
6380func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6381 defer func() {
6382 if r := recover(); r != nil {
6383 ec.Error(ctx, ec.Recover(ctx, r))
6384 ret = graphql.Null
6385 }
6386 }()
6387 fc := &graphql.FieldContext{
6388 Object: "Identity",
6389 Field: field,
6390 Args: nil,
6391 IsMethod: true,
6392 }
6393
6394 ctx = graphql.WithFieldContext(ctx, fc)
6395 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6396 ctx = rctx // use context from middleware stack in children
6397 return obj.DisplayName(), nil
6398 })
6399 if err != nil {
6400 ec.Error(ctx, err)
6401 return graphql.Null
6402 }
6403 if resTmp == nil {
6404 if !graphql.HasFieldError(ctx, fc) {
6405 ec.Errorf(ctx, "must not be null")
6406 }
6407 return graphql.Null
6408 }
6409 res := resTmp.(string)
6410 fc.Result = res
6411 return ec.marshalNString2string(ctx, field.Selections, res)
6412}
6413
6414func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6415 defer func() {
6416 if r := recover(); r != nil {
6417 ec.Error(ctx, ec.Recover(ctx, r))
6418 ret = graphql.Null
6419 }
6420 }()
6421 fc := &graphql.FieldContext{
6422 Object: "Identity",
6423 Field: field,
6424 Args: nil,
6425 IsMethod: true,
6426 }
6427
6428 ctx = graphql.WithFieldContext(ctx, fc)
6429 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6430 ctx = rctx // use context from middleware stack in children
6431 return obj.AvatarUrl()
6432 })
6433 if err != nil {
6434 ec.Error(ctx, err)
6435 return graphql.Null
6436 }
6437 if resTmp == nil {
6438 return graphql.Null
6439 }
6440 res := resTmp.(string)
6441 fc.Result = res
6442 return ec.marshalOString2string(ctx, field.Selections, res)
6443}
6444
6445func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6446 defer func() {
6447 if r := recover(); r != nil {
6448 ec.Error(ctx, ec.Recover(ctx, r))
6449 ret = graphql.Null
6450 }
6451 }()
6452 fc := &graphql.FieldContext{
6453 Object: "Identity",
6454 Field: field,
6455 Args: nil,
6456 IsMethod: true,
6457 }
6458
6459 ctx = graphql.WithFieldContext(ctx, fc)
6460 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6461 ctx = rctx // use context from middleware stack in children
6462 return obj.IsProtected()
6463 })
6464 if err != nil {
6465 ec.Error(ctx, err)
6466 return graphql.Null
6467 }
6468 if resTmp == nil {
6469 if !graphql.HasFieldError(ctx, fc) {
6470 ec.Errorf(ctx, "must not be null")
6471 }
6472 return graphql.Null
6473 }
6474 res := resTmp.(bool)
6475 fc.Result = res
6476 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
6477}
6478
6479func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6480 defer func() {
6481 if r := recover(); r != nil {
6482 ec.Error(ctx, ec.Recover(ctx, r))
6483 ret = graphql.Null
6484 }
6485 }()
6486 fc := &graphql.FieldContext{
6487 Object: "IdentityConnection",
6488 Field: field,
6489 Args: nil,
6490 IsMethod: false,
6491 }
6492
6493 ctx = graphql.WithFieldContext(ctx, fc)
6494 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6495 ctx = rctx // use context from middleware stack in children
6496 return obj.Edges, nil
6497 })
6498 if err != nil {
6499 ec.Error(ctx, err)
6500 return graphql.Null
6501 }
6502 if resTmp == nil {
6503 if !graphql.HasFieldError(ctx, fc) {
6504 ec.Errorf(ctx, "must not be null")
6505 }
6506 return graphql.Null
6507 }
6508 res := resTmp.([]*models.IdentityEdge)
6509 fc.Result = res
6510 return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx, field.Selections, res)
6511}
6512
6513func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6514 defer func() {
6515 if r := recover(); r != nil {
6516 ec.Error(ctx, ec.Recover(ctx, r))
6517 ret = graphql.Null
6518 }
6519 }()
6520 fc := &graphql.FieldContext{
6521 Object: "IdentityConnection",
6522 Field: field,
6523 Args: nil,
6524 IsMethod: false,
6525 }
6526
6527 ctx = graphql.WithFieldContext(ctx, fc)
6528 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6529 ctx = rctx // use context from middleware stack in children
6530 return obj.Nodes, nil
6531 })
6532 if err != nil {
6533 ec.Error(ctx, err)
6534 return graphql.Null
6535 }
6536 if resTmp == nil {
6537 if !graphql.HasFieldError(ctx, fc) {
6538 ec.Errorf(ctx, "must not be null")
6539 }
6540 return graphql.Null
6541 }
6542 res := resTmp.([]models.IdentityWrapper)
6543 fc.Result = res
6544 return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx, field.Selections, res)
6545}
6546
6547func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6548 defer func() {
6549 if r := recover(); r != nil {
6550 ec.Error(ctx, ec.Recover(ctx, r))
6551 ret = graphql.Null
6552 }
6553 }()
6554 fc := &graphql.FieldContext{
6555 Object: "IdentityConnection",
6556 Field: field,
6557 Args: nil,
6558 IsMethod: false,
6559 }
6560
6561 ctx = graphql.WithFieldContext(ctx, fc)
6562 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6563 ctx = rctx // use context from middleware stack in children
6564 return obj.PageInfo, nil
6565 })
6566 if err != nil {
6567 ec.Error(ctx, err)
6568 return graphql.Null
6569 }
6570 if resTmp == nil {
6571 if !graphql.HasFieldError(ctx, fc) {
6572 ec.Errorf(ctx, "must not be null")
6573 }
6574 return graphql.Null
6575 }
6576 res := resTmp.(*models.PageInfo)
6577 fc.Result = res
6578 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
6579}
6580
6581func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6582 defer func() {
6583 if r := recover(); r != nil {
6584 ec.Error(ctx, ec.Recover(ctx, r))
6585 ret = graphql.Null
6586 }
6587 }()
6588 fc := &graphql.FieldContext{
6589 Object: "IdentityConnection",
6590 Field: field,
6591 Args: nil,
6592 IsMethod: false,
6593 }
6594
6595 ctx = graphql.WithFieldContext(ctx, fc)
6596 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6597 ctx = rctx // use context from middleware stack in children
6598 return obj.TotalCount, nil
6599 })
6600 if err != nil {
6601 ec.Error(ctx, err)
6602 return graphql.Null
6603 }
6604 if resTmp == nil {
6605 if !graphql.HasFieldError(ctx, fc) {
6606 ec.Errorf(ctx, "must not be null")
6607 }
6608 return graphql.Null
6609 }
6610 res := resTmp.(int)
6611 fc.Result = res
6612 return ec.marshalNInt2int(ctx, field.Selections, res)
6613}
6614
6615func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6616 defer func() {
6617 if r := recover(); r != nil {
6618 ec.Error(ctx, ec.Recover(ctx, r))
6619 ret = graphql.Null
6620 }
6621 }()
6622 fc := &graphql.FieldContext{
6623 Object: "IdentityEdge",
6624 Field: field,
6625 Args: nil,
6626 IsMethod: false,
6627 }
6628
6629 ctx = graphql.WithFieldContext(ctx, fc)
6630 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6631 ctx = rctx // use context from middleware stack in children
6632 return obj.Cursor, nil
6633 })
6634 if err != nil {
6635 ec.Error(ctx, err)
6636 return graphql.Null
6637 }
6638 if resTmp == nil {
6639 if !graphql.HasFieldError(ctx, fc) {
6640 ec.Errorf(ctx, "must not be null")
6641 }
6642 return graphql.Null
6643 }
6644 res := resTmp.(string)
6645 fc.Result = res
6646 return ec.marshalNString2string(ctx, field.Selections, res)
6647}
6648
6649func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6650 defer func() {
6651 if r := recover(); r != nil {
6652 ec.Error(ctx, ec.Recover(ctx, r))
6653 ret = graphql.Null
6654 }
6655 }()
6656 fc := &graphql.FieldContext{
6657 Object: "IdentityEdge",
6658 Field: field,
6659 Args: nil,
6660 IsMethod: false,
6661 }
6662
6663 ctx = graphql.WithFieldContext(ctx, fc)
6664 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6665 ctx = rctx // use context from middleware stack in children
6666 return obj.Node, nil
6667 })
6668 if err != nil {
6669 ec.Error(ctx, err)
6670 return graphql.Null
6671 }
6672 if resTmp == nil {
6673 if !graphql.HasFieldError(ctx, fc) {
6674 ec.Errorf(ctx, "must not be null")
6675 }
6676 return graphql.Null
6677 }
6678 res := resTmp.(models.IdentityWrapper)
6679 fc.Result = res
6680 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6681}
6682
6683func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6684 defer func() {
6685 if r := recover(); r != nil {
6686 ec.Error(ctx, ec.Recover(ctx, r))
6687 ret = graphql.Null
6688 }
6689 }()
6690 fc := &graphql.FieldContext{
6691 Object: "Label",
6692 Field: field,
6693 Args: nil,
6694 IsMethod: true,
6695 }
6696
6697 ctx = graphql.WithFieldContext(ctx, fc)
6698 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6699 ctx = rctx // use context from middleware stack in children
6700 return ec.resolvers.Label().Name(rctx, obj)
6701 })
6702 if err != nil {
6703 ec.Error(ctx, err)
6704 return graphql.Null
6705 }
6706 if resTmp == nil {
6707 if !graphql.HasFieldError(ctx, fc) {
6708 ec.Errorf(ctx, "must not be null")
6709 }
6710 return graphql.Null
6711 }
6712 res := resTmp.(string)
6713 fc.Result = res
6714 return ec.marshalNString2string(ctx, field.Selections, res)
6715}
6716
6717func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
6718 defer func() {
6719 if r := recover(); r != nil {
6720 ec.Error(ctx, ec.Recover(ctx, r))
6721 ret = graphql.Null
6722 }
6723 }()
6724 fc := &graphql.FieldContext{
6725 Object: "Label",
6726 Field: field,
6727 Args: nil,
6728 IsMethod: true,
6729 }
6730
6731 ctx = graphql.WithFieldContext(ctx, fc)
6732 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6733 ctx = rctx // use context from middleware stack in children
6734 return ec.resolvers.Label().Color(rctx, obj)
6735 })
6736 if err != nil {
6737 ec.Error(ctx, err)
6738 return graphql.Null
6739 }
6740 if resTmp == nil {
6741 if !graphql.HasFieldError(ctx, fc) {
6742 ec.Errorf(ctx, "must not be null")
6743 }
6744 return graphql.Null
6745 }
6746 res := resTmp.(*color.RGBA)
6747 fc.Result = res
6748 return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
6749}
6750
6751func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6752 defer func() {
6753 if r := recover(); r != nil {
6754 ec.Error(ctx, ec.Recover(ctx, r))
6755 ret = graphql.Null
6756 }
6757 }()
6758 fc := &graphql.FieldContext{
6759 Object: "LabelChangeOperation",
6760 Field: field,
6761 Args: nil,
6762 IsMethod: true,
6763 }
6764
6765 ctx = graphql.WithFieldContext(ctx, fc)
6766 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6767 ctx = rctx // use context from middleware stack in children
6768 return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
6769 })
6770 if err != nil {
6771 ec.Error(ctx, err)
6772 return graphql.Null
6773 }
6774 if resTmp == nil {
6775 if !graphql.HasFieldError(ctx, fc) {
6776 ec.Errorf(ctx, "must not be null")
6777 }
6778 return graphql.Null
6779 }
6780 res := resTmp.(string)
6781 fc.Result = res
6782 return ec.marshalNString2string(ctx, field.Selections, res)
6783}
6784
6785func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6786 defer func() {
6787 if r := recover(); r != nil {
6788 ec.Error(ctx, ec.Recover(ctx, r))
6789 ret = graphql.Null
6790 }
6791 }()
6792 fc := &graphql.FieldContext{
6793 Object: "LabelChangeOperation",
6794 Field: field,
6795 Args: nil,
6796 IsMethod: true,
6797 }
6798
6799 ctx = graphql.WithFieldContext(ctx, fc)
6800 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6801 ctx = rctx // use context from middleware stack in children
6802 return ec.resolvers.LabelChangeOperation().Author(rctx, obj)
6803 })
6804 if err != nil {
6805 ec.Error(ctx, err)
6806 return graphql.Null
6807 }
6808 if resTmp == nil {
6809 if !graphql.HasFieldError(ctx, fc) {
6810 ec.Errorf(ctx, "must not be null")
6811 }
6812 return graphql.Null
6813 }
6814 res := resTmp.(models.IdentityWrapper)
6815 fc.Result = res
6816 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6817}
6818
6819func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6820 defer func() {
6821 if r := recover(); r != nil {
6822 ec.Error(ctx, ec.Recover(ctx, r))
6823 ret = graphql.Null
6824 }
6825 }()
6826 fc := &graphql.FieldContext{
6827 Object: "LabelChangeOperation",
6828 Field: field,
6829 Args: nil,
6830 IsMethod: true,
6831 }
6832
6833 ctx = graphql.WithFieldContext(ctx, fc)
6834 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6835 ctx = rctx // use context from middleware stack in children
6836 return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
6837 })
6838 if err != nil {
6839 ec.Error(ctx, err)
6840 return graphql.Null
6841 }
6842 if resTmp == nil {
6843 if !graphql.HasFieldError(ctx, fc) {
6844 ec.Errorf(ctx, "must not be null")
6845 }
6846 return graphql.Null
6847 }
6848 res := resTmp.(*time.Time)
6849 fc.Result = res
6850 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6851}
6852
6853func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6854 defer func() {
6855 if r := recover(); r != nil {
6856 ec.Error(ctx, ec.Recover(ctx, r))
6857 ret = graphql.Null
6858 }
6859 }()
6860 fc := &graphql.FieldContext{
6861 Object: "LabelChangeOperation",
6862 Field: field,
6863 Args: nil,
6864 IsMethod: false,
6865 }
6866
6867 ctx = graphql.WithFieldContext(ctx, fc)
6868 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6869 ctx = rctx // use context from middleware stack in children
6870 return obj.Added, nil
6871 })
6872 if err != nil {
6873 ec.Error(ctx, err)
6874 return graphql.Null
6875 }
6876 if resTmp == nil {
6877 if !graphql.HasFieldError(ctx, fc) {
6878 ec.Errorf(ctx, "must not be null")
6879 }
6880 return graphql.Null
6881 }
6882 res := resTmp.([]bug.Label)
6883 fc.Result = res
6884 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6885}
6886
6887func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6888 defer func() {
6889 if r := recover(); r != nil {
6890 ec.Error(ctx, ec.Recover(ctx, r))
6891 ret = graphql.Null
6892 }
6893 }()
6894 fc := &graphql.FieldContext{
6895 Object: "LabelChangeOperation",
6896 Field: field,
6897 Args: nil,
6898 IsMethod: false,
6899 }
6900
6901 ctx = graphql.WithFieldContext(ctx, fc)
6902 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6903 ctx = rctx // use context from middleware stack in children
6904 return obj.Removed, nil
6905 })
6906 if err != nil {
6907 ec.Error(ctx, err)
6908 return graphql.Null
6909 }
6910 if resTmp == nil {
6911 if !graphql.HasFieldError(ctx, fc) {
6912 ec.Errorf(ctx, "must not be null")
6913 }
6914 return graphql.Null
6915 }
6916 res := resTmp.([]bug.Label)
6917 fc.Result = res
6918 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6919}
6920
6921func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6922 defer func() {
6923 if r := recover(); r != nil {
6924 ec.Error(ctx, ec.Recover(ctx, r))
6925 ret = graphql.Null
6926 }
6927 }()
6928 fc := &graphql.FieldContext{
6929 Object: "LabelChangeResult",
6930 Field: field,
6931 Args: nil,
6932 IsMethod: false,
6933 }
6934
6935 ctx = graphql.WithFieldContext(ctx, fc)
6936 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6937 ctx = rctx // use context from middleware stack in children
6938 return obj.Label, nil
6939 })
6940 if err != nil {
6941 ec.Error(ctx, err)
6942 return graphql.Null
6943 }
6944 if resTmp == nil {
6945 if !graphql.HasFieldError(ctx, fc) {
6946 ec.Errorf(ctx, "must not be null")
6947 }
6948 return graphql.Null
6949 }
6950 res := resTmp.(bug.Label)
6951 fc.Result = res
6952 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
6953}
6954
6955func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6956 defer func() {
6957 if r := recover(); r != nil {
6958 ec.Error(ctx, ec.Recover(ctx, r))
6959 ret = graphql.Null
6960 }
6961 }()
6962 fc := &graphql.FieldContext{
6963 Object: "LabelChangeResult",
6964 Field: field,
6965 Args: nil,
6966 IsMethod: true,
6967 }
6968
6969 ctx = graphql.WithFieldContext(ctx, fc)
6970 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6971 ctx = rctx // use context from middleware stack in children
6972 return ec.resolvers.LabelChangeResult().Status(rctx, obj)
6973 })
6974 if err != nil {
6975 ec.Error(ctx, err)
6976 return graphql.Null
6977 }
6978 if resTmp == nil {
6979 if !graphql.HasFieldError(ctx, fc) {
6980 ec.Errorf(ctx, "must not be null")
6981 }
6982 return graphql.Null
6983 }
6984 res := resTmp.(models.LabelChangeStatus)
6985 fc.Result = res
6986 return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
6987}
6988
6989func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6990 defer func() {
6991 if r := recover(); r != nil {
6992 ec.Error(ctx, ec.Recover(ctx, r))
6993 ret = graphql.Null
6994 }
6995 }()
6996 fc := &graphql.FieldContext{
6997 Object: "LabelChangeTimelineItem",
6998 Field: field,
6999 Args: nil,
7000 IsMethod: true,
7001 }
7002
7003 ctx = graphql.WithFieldContext(ctx, fc)
7004 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7005 ctx = rctx // use context from middleware stack in children
7006 return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
7007 })
7008 if err != nil {
7009 ec.Error(ctx, err)
7010 return graphql.Null
7011 }
7012 if resTmp == nil {
7013 if !graphql.HasFieldError(ctx, fc) {
7014 ec.Errorf(ctx, "must not be null")
7015 }
7016 return graphql.Null
7017 }
7018 res := resTmp.(string)
7019 fc.Result = res
7020 return ec.marshalNString2string(ctx, field.Selections, res)
7021}
7022
7023func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
7024 defer func() {
7025 if r := recover(); r != nil {
7026 ec.Error(ctx, ec.Recover(ctx, r))
7027 ret = graphql.Null
7028 }
7029 }()
7030 fc := &graphql.FieldContext{
7031 Object: "LabelChangeTimelineItem",
7032 Field: field,
7033 Args: nil,
7034 IsMethod: true,
7035 }
7036
7037 ctx = graphql.WithFieldContext(ctx, fc)
7038 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7039 ctx = rctx // use context from middleware stack in children
7040 return ec.resolvers.LabelChangeTimelineItem().Author(rctx, obj)
7041 })
7042 if err != nil {
7043 ec.Error(ctx, err)
7044 return graphql.Null
7045 }
7046 if resTmp == nil {
7047 if !graphql.HasFieldError(ctx, fc) {
7048 ec.Errorf(ctx, "must not be null")
7049 }
7050 return graphql.Null
7051 }
7052 res := resTmp.(models.IdentityWrapper)
7053 fc.Result = res
7054 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
7055}
7056
7057func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
7058 defer func() {
7059 if r := recover(); r != nil {
7060 ec.Error(ctx, ec.Recover(ctx, r))
7061 ret = graphql.Null
7062 }
7063 }()
7064 fc := &graphql.FieldContext{
7065 Object: "LabelChangeTimelineItem",
7066 Field: field,
7067 Args: nil,
7068 IsMethod: true,
7069 }
7070
7071 ctx = graphql.WithFieldContext(ctx, fc)
7072 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7073 ctx = rctx // use context from middleware stack in children
7074 return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
7075 })
7076 if err != nil {
7077 ec.Error(ctx, err)
7078 return graphql.Null
7079 }
7080 if resTmp == nil {
7081 if !graphql.HasFieldError(ctx, fc) {
7082 ec.Errorf(ctx, "must not be null")
7083 }
7084 return graphql.Null
7085 }
7086 res := resTmp.(*time.Time)
7087 fc.Result = res
7088 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
7089}
7090
7091func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
7092 defer func() {
7093 if r := recover(); r != nil {
7094 ec.Error(ctx, ec.Recover(ctx, r))
7095 ret = graphql.Null
7096 }
7097 }()
7098 fc := &graphql.FieldContext{
7099 Object: "LabelChangeTimelineItem",
7100 Field: field,
7101 Args: nil,
7102 IsMethod: false,
7103 }
7104
7105 ctx = graphql.WithFieldContext(ctx, fc)
7106 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7107 ctx = rctx // use context from middleware stack in children
7108 return obj.Added, nil
7109 })
7110 if err != nil {
7111 ec.Error(ctx, err)
7112 return graphql.Null
7113 }
7114 if resTmp == nil {
7115 if !graphql.HasFieldError(ctx, fc) {
7116 ec.Errorf(ctx, "must not be null")
7117 }
7118 return graphql.Null
7119 }
7120 res := resTmp.([]bug.Label)
7121 fc.Result = res
7122 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
7123}
7124
7125func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
7126 defer func() {
7127 if r := recover(); r != nil {
7128 ec.Error(ctx, ec.Recover(ctx, r))
7129 ret = graphql.Null
7130 }
7131 }()
7132 fc := &graphql.FieldContext{
7133 Object: "LabelChangeTimelineItem",
7134 Field: field,
7135 Args: nil,
7136 IsMethod: false,
7137 }
7138
7139 ctx = graphql.WithFieldContext(ctx, fc)
7140 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7141 ctx = rctx // use context from middleware stack in children
7142 return obj.Removed, nil
7143 })
7144 if err != nil {
7145 ec.Error(ctx, err)
7146 return graphql.Null
7147 }
7148 if resTmp == nil {
7149 if !graphql.HasFieldError(ctx, fc) {
7150 ec.Errorf(ctx, "must not be null")
7151 }
7152 return graphql.Null
7153 }
7154 res := resTmp.([]bug.Label)
7155 fc.Result = res
7156 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
7157}
7158
7159func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7160 defer func() {
7161 if r := recover(); r != nil {
7162 ec.Error(ctx, ec.Recover(ctx, r))
7163 ret = graphql.Null
7164 }
7165 }()
7166 fc := &graphql.FieldContext{
7167 Object: "LabelConnection",
7168 Field: field,
7169 Args: nil,
7170 IsMethod: false,
7171 }
7172
7173 ctx = graphql.WithFieldContext(ctx, fc)
7174 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7175 ctx = rctx // use context from middleware stack in children
7176 return obj.Edges, nil
7177 })
7178 if err != nil {
7179 ec.Error(ctx, err)
7180 return graphql.Null
7181 }
7182 if resTmp == nil {
7183 if !graphql.HasFieldError(ctx, fc) {
7184 ec.Errorf(ctx, "must not be null")
7185 }
7186 return graphql.Null
7187 }
7188 res := resTmp.([]*models.LabelEdge)
7189 fc.Result = res
7190 return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx, field.Selections, res)
7191}
7192
7193func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7194 defer func() {
7195 if r := recover(); r != nil {
7196 ec.Error(ctx, ec.Recover(ctx, r))
7197 ret = graphql.Null
7198 }
7199 }()
7200 fc := &graphql.FieldContext{
7201 Object: "LabelConnection",
7202 Field: field,
7203 Args: nil,
7204 IsMethod: false,
7205 }
7206
7207 ctx = graphql.WithFieldContext(ctx, fc)
7208 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7209 ctx = rctx // use context from middleware stack in children
7210 return obj.Nodes, nil
7211 })
7212 if err != nil {
7213 ec.Error(ctx, err)
7214 return graphql.Null
7215 }
7216 if resTmp == nil {
7217 if !graphql.HasFieldError(ctx, fc) {
7218 ec.Errorf(ctx, "must not be null")
7219 }
7220 return graphql.Null
7221 }
7222 res := resTmp.([]bug.Label)
7223 fc.Result = res
7224 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
7225}
7226
7227func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7228 defer func() {
7229 if r := recover(); r != nil {
7230 ec.Error(ctx, ec.Recover(ctx, r))
7231 ret = graphql.Null
7232 }
7233 }()
7234 fc := &graphql.FieldContext{
7235 Object: "LabelConnection",
7236 Field: field,
7237 Args: nil,
7238 IsMethod: false,
7239 }
7240
7241 ctx = graphql.WithFieldContext(ctx, fc)
7242 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7243 ctx = rctx // use context from middleware stack in children
7244 return obj.PageInfo, nil
7245 })
7246 if err != nil {
7247 ec.Error(ctx, err)
7248 return graphql.Null
7249 }
7250 if resTmp == nil {
7251 if !graphql.HasFieldError(ctx, fc) {
7252 ec.Errorf(ctx, "must not be null")
7253 }
7254 return graphql.Null
7255 }
7256 res := resTmp.(*models.PageInfo)
7257 fc.Result = res
7258 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
7259}
7260
7261func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
7262 defer func() {
7263 if r := recover(); r != nil {
7264 ec.Error(ctx, ec.Recover(ctx, r))
7265 ret = graphql.Null
7266 }
7267 }()
7268 fc := &graphql.FieldContext{
7269 Object: "LabelConnection",
7270 Field: field,
7271 Args: nil,
7272 IsMethod: false,
7273 }
7274
7275 ctx = graphql.WithFieldContext(ctx, fc)
7276 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7277 ctx = rctx // use context from middleware stack in children
7278 return obj.TotalCount, nil
7279 })
7280 if err != nil {
7281 ec.Error(ctx, err)
7282 return graphql.Null
7283 }
7284 if resTmp == nil {
7285 if !graphql.HasFieldError(ctx, fc) {
7286 ec.Errorf(ctx, "must not be null")
7287 }
7288 return graphql.Null
7289 }
7290 res := resTmp.(int)
7291 fc.Result = res
7292 return ec.marshalNInt2int(ctx, field.Selections, res)
7293}
7294
7295func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
7296 defer func() {
7297 if r := recover(); r != nil {
7298 ec.Error(ctx, ec.Recover(ctx, r))
7299 ret = graphql.Null
7300 }
7301 }()
7302 fc := &graphql.FieldContext{
7303 Object: "LabelEdge",
7304 Field: field,
7305 Args: nil,
7306 IsMethod: false,
7307 }
7308
7309 ctx = graphql.WithFieldContext(ctx, fc)
7310 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7311 ctx = rctx // use context from middleware stack in children
7312 return obj.Cursor, nil
7313 })
7314 if err != nil {
7315 ec.Error(ctx, err)
7316 return graphql.Null
7317 }
7318 if resTmp == nil {
7319 if !graphql.HasFieldError(ctx, fc) {
7320 ec.Errorf(ctx, "must not be null")
7321 }
7322 return graphql.Null
7323 }
7324 res := resTmp.(string)
7325 fc.Result = res
7326 return ec.marshalNString2string(ctx, field.Selections, res)
7327}
7328
7329func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
7330 defer func() {
7331 if r := recover(); r != nil {
7332 ec.Error(ctx, ec.Recover(ctx, r))
7333 ret = graphql.Null
7334 }
7335 }()
7336 fc := &graphql.FieldContext{
7337 Object: "LabelEdge",
7338 Field: field,
7339 Args: nil,
7340 IsMethod: false,
7341 }
7342
7343 ctx = graphql.WithFieldContext(ctx, fc)
7344 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7345 ctx = rctx // use context from middleware stack in children
7346 return obj.Node, nil
7347 })
7348 if err != nil {
7349 ec.Error(ctx, err)
7350 return graphql.Null
7351 }
7352 if resTmp == nil {
7353 if !graphql.HasFieldError(ctx, fc) {
7354 ec.Errorf(ctx, "must not be null")
7355 }
7356 return graphql.Null
7357 }
7358 res := resTmp.(bug.Label)
7359 fc.Result = res
7360 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
7361}
7362
7363func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7364 defer func() {
7365 if r := recover(); r != nil {
7366 ec.Error(ctx, ec.Recover(ctx, r))
7367 ret = graphql.Null
7368 }
7369 }()
7370 fc := &graphql.FieldContext{
7371 Object: "Mutation",
7372 Field: field,
7373 Args: nil,
7374 IsMethod: true,
7375 }
7376
7377 ctx = graphql.WithFieldContext(ctx, fc)
7378 rawArgs := field.ArgumentMap(ec.Variables)
7379 args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
7380 if err != nil {
7381 ec.Error(ctx, err)
7382 return graphql.Null
7383 }
7384 fc.Args = args
7385 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7386 ctx = rctx // use context from middleware stack in children
7387 return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
7388 })
7389 if err != nil {
7390 ec.Error(ctx, err)
7391 return graphql.Null
7392 }
7393 if resTmp == nil {
7394 if !graphql.HasFieldError(ctx, fc) {
7395 ec.Errorf(ctx, "must not be null")
7396 }
7397 return graphql.Null
7398 }
7399 res := resTmp.(*models.NewBugPayload)
7400 fc.Result = res
7401 return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
7402}
7403
7404func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7405 defer func() {
7406 if r := recover(); r != nil {
7407 ec.Error(ctx, ec.Recover(ctx, r))
7408 ret = graphql.Null
7409 }
7410 }()
7411 fc := &graphql.FieldContext{
7412 Object: "Mutation",
7413 Field: field,
7414 Args: nil,
7415 IsMethod: true,
7416 }
7417
7418 ctx = graphql.WithFieldContext(ctx, fc)
7419 rawArgs := field.ArgumentMap(ec.Variables)
7420 args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
7421 if err != nil {
7422 ec.Error(ctx, err)
7423 return graphql.Null
7424 }
7425 fc.Args = args
7426 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7427 ctx = rctx // use context from middleware stack in children
7428 return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
7429 })
7430 if err != nil {
7431 ec.Error(ctx, err)
7432 return graphql.Null
7433 }
7434 if resTmp == nil {
7435 if !graphql.HasFieldError(ctx, fc) {
7436 ec.Errorf(ctx, "must not be null")
7437 }
7438 return graphql.Null
7439 }
7440 res := resTmp.(*models.AddCommentPayload)
7441 fc.Result = res
7442 return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
7443}
7444
7445func (ec *executionContext) _Mutation_addCommentAndClose(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7446 defer func() {
7447 if r := recover(); r != nil {
7448 ec.Error(ctx, ec.Recover(ctx, r))
7449 ret = graphql.Null
7450 }
7451 }()
7452 fc := &graphql.FieldContext{
7453 Object: "Mutation",
7454 Field: field,
7455 Args: nil,
7456 IsMethod: true,
7457 }
7458
7459 ctx = graphql.WithFieldContext(ctx, fc)
7460 rawArgs := field.ArgumentMap(ec.Variables)
7461 args, err := ec.field_Mutation_addCommentAndClose_args(ctx, rawArgs)
7462 if err != nil {
7463 ec.Error(ctx, err)
7464 return graphql.Null
7465 }
7466 fc.Args = args
7467 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7468 ctx = rctx // use context from middleware stack in children
7469 return ec.resolvers.Mutation().AddCommentAndClose(rctx, args["input"].(models.AddCommentAndCloseBugInput))
7470 })
7471 if err != nil {
7472 ec.Error(ctx, err)
7473 return graphql.Null
7474 }
7475 if resTmp == nil {
7476 if !graphql.HasFieldError(ctx, fc) {
7477 ec.Errorf(ctx, "must not be null")
7478 }
7479 return graphql.Null
7480 }
7481 res := resTmp.(*models.AddCommentAndCloseBugPayload)
7482 fc.Result = res
7483 return ec.marshalNAddCommentAndCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx, field.Selections, res)
7484}
7485
7486func (ec *executionContext) _Mutation_addCommentAndReopen(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7487 defer func() {
7488 if r := recover(); r != nil {
7489 ec.Error(ctx, ec.Recover(ctx, r))
7490 ret = graphql.Null
7491 }
7492 }()
7493 fc := &graphql.FieldContext{
7494 Object: "Mutation",
7495 Field: field,
7496 Args: nil,
7497 IsMethod: true,
7498 }
7499
7500 ctx = graphql.WithFieldContext(ctx, fc)
7501 rawArgs := field.ArgumentMap(ec.Variables)
7502 args, err := ec.field_Mutation_addCommentAndReopen_args(ctx, rawArgs)
7503 if err != nil {
7504 ec.Error(ctx, err)
7505 return graphql.Null
7506 }
7507 fc.Args = args
7508 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7509 ctx = rctx // use context from middleware stack in children
7510 return ec.resolvers.Mutation().AddCommentAndReopen(rctx, args["input"].(models.AddCommentAndReopenBugInput))
7511 })
7512 if err != nil {
7513 ec.Error(ctx, err)
7514 return graphql.Null
7515 }
7516 if resTmp == nil {
7517 if !graphql.HasFieldError(ctx, fc) {
7518 ec.Errorf(ctx, "must not be null")
7519 }
7520 return graphql.Null
7521 }
7522 res := resTmp.(*models.AddCommentAndReopenBugPayload)
7523 fc.Result = res
7524 return ec.marshalNAddCommentAndReopenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx, field.Selections, res)
7525}
7526
7527func (ec *executionContext) _Mutation_editComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7528 defer func() {
7529 if r := recover(); r != nil {
7530 ec.Error(ctx, ec.Recover(ctx, r))
7531 ret = graphql.Null
7532 }
7533 }()
7534 fc := &graphql.FieldContext{
7535 Object: "Mutation",
7536 Field: field,
7537 Args: nil,
7538 IsMethod: true,
7539 }
7540
7541 ctx = graphql.WithFieldContext(ctx, fc)
7542 rawArgs := field.ArgumentMap(ec.Variables)
7543 args, err := ec.field_Mutation_editComment_args(ctx, rawArgs)
7544 if err != nil {
7545 ec.Error(ctx, err)
7546 return graphql.Null
7547 }
7548 fc.Args = args
7549 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7550 ctx = rctx // use context from middleware stack in children
7551 return ec.resolvers.Mutation().EditComment(rctx, args["input"].(models.EditCommentInput))
7552 })
7553 if err != nil {
7554 ec.Error(ctx, err)
7555 return graphql.Null
7556 }
7557 if resTmp == nil {
7558 if !graphql.HasFieldError(ctx, fc) {
7559 ec.Errorf(ctx, "must not be null")
7560 }
7561 return graphql.Null
7562 }
7563 res := resTmp.(*models.EditCommentPayload)
7564 fc.Result = res
7565 return ec.marshalNEditCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx, field.Selections, res)
7566}
7567
7568func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7569 defer func() {
7570 if r := recover(); r != nil {
7571 ec.Error(ctx, ec.Recover(ctx, r))
7572 ret = graphql.Null
7573 }
7574 }()
7575 fc := &graphql.FieldContext{
7576 Object: "Mutation",
7577 Field: field,
7578 Args: nil,
7579 IsMethod: true,
7580 }
7581
7582 ctx = graphql.WithFieldContext(ctx, fc)
7583 rawArgs := field.ArgumentMap(ec.Variables)
7584 args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
7585 if err != nil {
7586 ec.Error(ctx, err)
7587 return graphql.Null
7588 }
7589 fc.Args = args
7590 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7591 ctx = rctx // use context from middleware stack in children
7592 return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
7593 })
7594 if err != nil {
7595 ec.Error(ctx, err)
7596 return graphql.Null
7597 }
7598 if resTmp == nil {
7599 if !graphql.HasFieldError(ctx, fc) {
7600 ec.Errorf(ctx, "must not be null")
7601 }
7602 return graphql.Null
7603 }
7604 res := resTmp.(*models.ChangeLabelPayload)
7605 fc.Result = res
7606 return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
7607}
7608
7609func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7610 defer func() {
7611 if r := recover(); r != nil {
7612 ec.Error(ctx, ec.Recover(ctx, r))
7613 ret = graphql.Null
7614 }
7615 }()
7616 fc := &graphql.FieldContext{
7617 Object: "Mutation",
7618 Field: field,
7619 Args: nil,
7620 IsMethod: true,
7621 }
7622
7623 ctx = graphql.WithFieldContext(ctx, fc)
7624 rawArgs := field.ArgumentMap(ec.Variables)
7625 args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
7626 if err != nil {
7627 ec.Error(ctx, err)
7628 return graphql.Null
7629 }
7630 fc.Args = args
7631 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7632 ctx = rctx // use context from middleware stack in children
7633 return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
7634 })
7635 if err != nil {
7636 ec.Error(ctx, err)
7637 return graphql.Null
7638 }
7639 if resTmp == nil {
7640 if !graphql.HasFieldError(ctx, fc) {
7641 ec.Errorf(ctx, "must not be null")
7642 }
7643 return graphql.Null
7644 }
7645 res := resTmp.(*models.OpenBugPayload)
7646 fc.Result = res
7647 return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
7648}
7649
7650func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7651 defer func() {
7652 if r := recover(); r != nil {
7653 ec.Error(ctx, ec.Recover(ctx, r))
7654 ret = graphql.Null
7655 }
7656 }()
7657 fc := &graphql.FieldContext{
7658 Object: "Mutation",
7659 Field: field,
7660 Args: nil,
7661 IsMethod: true,
7662 }
7663
7664 ctx = graphql.WithFieldContext(ctx, fc)
7665 rawArgs := field.ArgumentMap(ec.Variables)
7666 args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
7667 if err != nil {
7668 ec.Error(ctx, err)
7669 return graphql.Null
7670 }
7671 fc.Args = args
7672 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7673 ctx = rctx // use context from middleware stack in children
7674 return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
7675 })
7676 if err != nil {
7677 ec.Error(ctx, err)
7678 return graphql.Null
7679 }
7680 if resTmp == nil {
7681 if !graphql.HasFieldError(ctx, fc) {
7682 ec.Errorf(ctx, "must not be null")
7683 }
7684 return graphql.Null
7685 }
7686 res := resTmp.(*models.CloseBugPayload)
7687 fc.Result = res
7688 return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
7689}
7690
7691func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7692 defer func() {
7693 if r := recover(); r != nil {
7694 ec.Error(ctx, ec.Recover(ctx, r))
7695 ret = graphql.Null
7696 }
7697 }()
7698 fc := &graphql.FieldContext{
7699 Object: "Mutation",
7700 Field: field,
7701 Args: nil,
7702 IsMethod: true,
7703 }
7704
7705 ctx = graphql.WithFieldContext(ctx, fc)
7706 rawArgs := field.ArgumentMap(ec.Variables)
7707 args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
7708 if err != nil {
7709 ec.Error(ctx, err)
7710 return graphql.Null
7711 }
7712 fc.Args = args
7713 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7714 ctx = rctx // use context from middleware stack in children
7715 return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
7716 })
7717 if err != nil {
7718 ec.Error(ctx, err)
7719 return graphql.Null
7720 }
7721 if resTmp == nil {
7722 if !graphql.HasFieldError(ctx, fc) {
7723 ec.Errorf(ctx, "must not be null")
7724 }
7725 return graphql.Null
7726 }
7727 res := resTmp.(*models.SetTitlePayload)
7728 fc.Result = res
7729 return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
7730}
7731
7732func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7733 defer func() {
7734 if r := recover(); r != nil {
7735 ec.Error(ctx, ec.Recover(ctx, r))
7736 ret = graphql.Null
7737 }
7738 }()
7739 fc := &graphql.FieldContext{
7740 Object: "NewBugPayload",
7741 Field: field,
7742 Args: nil,
7743 IsMethod: false,
7744 }
7745
7746 ctx = graphql.WithFieldContext(ctx, fc)
7747 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7748 ctx = rctx // use context from middleware stack in children
7749 return obj.ClientMutationID, nil
7750 })
7751 if err != nil {
7752 ec.Error(ctx, err)
7753 return graphql.Null
7754 }
7755 if resTmp == nil {
7756 return graphql.Null
7757 }
7758 res := resTmp.(*string)
7759 fc.Result = res
7760 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7761}
7762
7763func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7764 defer func() {
7765 if r := recover(); r != nil {
7766 ec.Error(ctx, ec.Recover(ctx, r))
7767 ret = graphql.Null
7768 }
7769 }()
7770 fc := &graphql.FieldContext{
7771 Object: "NewBugPayload",
7772 Field: field,
7773 Args: nil,
7774 IsMethod: false,
7775 }
7776
7777 ctx = graphql.WithFieldContext(ctx, fc)
7778 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7779 ctx = rctx // use context from middleware stack in children
7780 return obj.Bug, nil
7781 })
7782 if err != nil {
7783 ec.Error(ctx, err)
7784 return graphql.Null
7785 }
7786 if resTmp == nil {
7787 if !graphql.HasFieldError(ctx, fc) {
7788 ec.Errorf(ctx, "must not be null")
7789 }
7790 return graphql.Null
7791 }
7792 res := resTmp.(models.BugWrapper)
7793 fc.Result = res
7794 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
7795}
7796
7797func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7798 defer func() {
7799 if r := recover(); r != nil {
7800 ec.Error(ctx, ec.Recover(ctx, r))
7801 ret = graphql.Null
7802 }
7803 }()
7804 fc := &graphql.FieldContext{
7805 Object: "NewBugPayload",
7806 Field: field,
7807 Args: nil,
7808 IsMethod: false,
7809 }
7810
7811 ctx = graphql.WithFieldContext(ctx, fc)
7812 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7813 ctx = rctx // use context from middleware stack in children
7814 return obj.Operation, nil
7815 })
7816 if err != nil {
7817 ec.Error(ctx, err)
7818 return graphql.Null
7819 }
7820 if resTmp == nil {
7821 if !graphql.HasFieldError(ctx, fc) {
7822 ec.Errorf(ctx, "must not be null")
7823 }
7824 return graphql.Null
7825 }
7826 res := resTmp.(*bug.CreateOperation)
7827 fc.Result = res
7828 return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
7829}
7830
7831func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7832 defer func() {
7833 if r := recover(); r != nil {
7834 ec.Error(ctx, ec.Recover(ctx, r))
7835 ret = graphql.Null
7836 }
7837 }()
7838 fc := &graphql.FieldContext{
7839 Object: "OpenBugPayload",
7840 Field: field,
7841 Args: nil,
7842 IsMethod: false,
7843 }
7844
7845 ctx = graphql.WithFieldContext(ctx, fc)
7846 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7847 ctx = rctx // use context from middleware stack in children
7848 return obj.ClientMutationID, nil
7849 })
7850 if err != nil {
7851 ec.Error(ctx, err)
7852 return graphql.Null
7853 }
7854 if resTmp == nil {
7855 return graphql.Null
7856 }
7857 res := resTmp.(*string)
7858 fc.Result = res
7859 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7860}
7861
7862func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7863 defer func() {
7864 if r := recover(); r != nil {
7865 ec.Error(ctx, ec.Recover(ctx, r))
7866 ret = graphql.Null
7867 }
7868 }()
7869 fc := &graphql.FieldContext{
7870 Object: "OpenBugPayload",
7871 Field: field,
7872 Args: nil,
7873 IsMethod: false,
7874 }
7875
7876 ctx = graphql.WithFieldContext(ctx, fc)
7877 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7878 ctx = rctx // use context from middleware stack in children
7879 return obj.Bug, nil
7880 })
7881 if err != nil {
7882 ec.Error(ctx, err)
7883 return graphql.Null
7884 }
7885 if resTmp == nil {
7886 if !graphql.HasFieldError(ctx, fc) {
7887 ec.Errorf(ctx, "must not be null")
7888 }
7889 return graphql.Null
7890 }
7891 res := resTmp.(models.BugWrapper)
7892 fc.Result = res
7893 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
7894}
7895
7896func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7897 defer func() {
7898 if r := recover(); r != nil {
7899 ec.Error(ctx, ec.Recover(ctx, r))
7900 ret = graphql.Null
7901 }
7902 }()
7903 fc := &graphql.FieldContext{
7904 Object: "OpenBugPayload",
7905 Field: field,
7906 Args: nil,
7907 IsMethod: false,
7908 }
7909
7910 ctx = graphql.WithFieldContext(ctx, fc)
7911 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7912 ctx = rctx // use context from middleware stack in children
7913 return obj.Operation, nil
7914 })
7915 if err != nil {
7916 ec.Error(ctx, err)
7917 return graphql.Null
7918 }
7919 if resTmp == nil {
7920 if !graphql.HasFieldError(ctx, fc) {
7921 ec.Errorf(ctx, "must not be null")
7922 }
7923 return graphql.Null
7924 }
7925 res := resTmp.(*bug.SetStatusOperation)
7926 fc.Result = res
7927 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
7928}
7929
7930func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7931 defer func() {
7932 if r := recover(); r != nil {
7933 ec.Error(ctx, ec.Recover(ctx, r))
7934 ret = graphql.Null
7935 }
7936 }()
7937 fc := &graphql.FieldContext{
7938 Object: "OperationConnection",
7939 Field: field,
7940 Args: nil,
7941 IsMethod: false,
7942 }
7943
7944 ctx = graphql.WithFieldContext(ctx, fc)
7945 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7946 ctx = rctx // use context from middleware stack in children
7947 return obj.Edges, nil
7948 })
7949 if err != nil {
7950 ec.Error(ctx, err)
7951 return graphql.Null
7952 }
7953 if resTmp == nil {
7954 if !graphql.HasFieldError(ctx, fc) {
7955 ec.Errorf(ctx, "must not be null")
7956 }
7957 return graphql.Null
7958 }
7959 res := resTmp.([]*models.OperationEdge)
7960 fc.Result = res
7961 return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
7962}
7963
7964func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7965 defer func() {
7966 if r := recover(); r != nil {
7967 ec.Error(ctx, ec.Recover(ctx, r))
7968 ret = graphql.Null
7969 }
7970 }()
7971 fc := &graphql.FieldContext{
7972 Object: "OperationConnection",
7973 Field: field,
7974 Args: nil,
7975 IsMethod: false,
7976 }
7977
7978 ctx = graphql.WithFieldContext(ctx, fc)
7979 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7980 ctx = rctx // use context from middleware stack in children
7981 return obj.Nodes, nil
7982 })
7983 if err != nil {
7984 ec.Error(ctx, err)
7985 return graphql.Null
7986 }
7987 if resTmp == nil {
7988 if !graphql.HasFieldError(ctx, fc) {
7989 ec.Errorf(ctx, "must not be null")
7990 }
7991 return graphql.Null
7992 }
7993 res := resTmp.([]bug.Operation)
7994 fc.Result = res
7995 return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx, field.Selections, res)
7996}
7997
7998func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7999 defer func() {
8000 if r := recover(); r != nil {
8001 ec.Error(ctx, ec.Recover(ctx, r))
8002 ret = graphql.Null
8003 }
8004 }()
8005 fc := &graphql.FieldContext{
8006 Object: "OperationConnection",
8007 Field: field,
8008 Args: nil,
8009 IsMethod: false,
8010 }
8011
8012 ctx = graphql.WithFieldContext(ctx, fc)
8013 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8014 ctx = rctx // use context from middleware stack in children
8015 return obj.PageInfo, nil
8016 })
8017 if err != nil {
8018 ec.Error(ctx, err)
8019 return graphql.Null
8020 }
8021 if resTmp == nil {
8022 if !graphql.HasFieldError(ctx, fc) {
8023 ec.Errorf(ctx, "must not be null")
8024 }
8025 return graphql.Null
8026 }
8027 res := resTmp.(*models.PageInfo)
8028 fc.Result = res
8029 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
8030}
8031
8032func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
8033 defer func() {
8034 if r := recover(); r != nil {
8035 ec.Error(ctx, ec.Recover(ctx, r))
8036 ret = graphql.Null
8037 }
8038 }()
8039 fc := &graphql.FieldContext{
8040 Object: "OperationConnection",
8041 Field: field,
8042 Args: nil,
8043 IsMethod: false,
8044 }
8045
8046 ctx = graphql.WithFieldContext(ctx, fc)
8047 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8048 ctx = rctx // use context from middleware stack in children
8049 return obj.TotalCount, nil
8050 })
8051 if err != nil {
8052 ec.Error(ctx, err)
8053 return graphql.Null
8054 }
8055 if resTmp == nil {
8056 if !graphql.HasFieldError(ctx, fc) {
8057 ec.Errorf(ctx, "must not be null")
8058 }
8059 return graphql.Null
8060 }
8061 res := resTmp.(int)
8062 fc.Result = res
8063 return ec.marshalNInt2int(ctx, field.Selections, res)
8064}
8065
8066func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
8067 defer func() {
8068 if r := recover(); r != nil {
8069 ec.Error(ctx, ec.Recover(ctx, r))
8070 ret = graphql.Null
8071 }
8072 }()
8073 fc := &graphql.FieldContext{
8074 Object: "OperationEdge",
8075 Field: field,
8076 Args: nil,
8077 IsMethod: false,
8078 }
8079
8080 ctx = graphql.WithFieldContext(ctx, fc)
8081 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8082 ctx = rctx // use context from middleware stack in children
8083 return obj.Cursor, nil
8084 })
8085 if err != nil {
8086 ec.Error(ctx, err)
8087 return graphql.Null
8088 }
8089 if resTmp == nil {
8090 if !graphql.HasFieldError(ctx, fc) {
8091 ec.Errorf(ctx, "must not be null")
8092 }
8093 return graphql.Null
8094 }
8095 res := resTmp.(string)
8096 fc.Result = res
8097 return ec.marshalNString2string(ctx, field.Selections, res)
8098}
8099
8100func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
8101 defer func() {
8102 if r := recover(); r != nil {
8103 ec.Error(ctx, ec.Recover(ctx, r))
8104 ret = graphql.Null
8105 }
8106 }()
8107 fc := &graphql.FieldContext{
8108 Object: "OperationEdge",
8109 Field: field,
8110 Args: nil,
8111 IsMethod: false,
8112 }
8113
8114 ctx = graphql.WithFieldContext(ctx, fc)
8115 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8116 ctx = rctx // use context from middleware stack in children
8117 return obj.Node, nil
8118 })
8119 if err != nil {
8120 ec.Error(ctx, err)
8121 return graphql.Null
8122 }
8123 if resTmp == nil {
8124 if !graphql.HasFieldError(ctx, fc) {
8125 ec.Errorf(ctx, "must not be null")
8126 }
8127 return graphql.Null
8128 }
8129 res := resTmp.(bug.Operation)
8130 fc.Result = res
8131 return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
8132}
8133
8134func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8135 defer func() {
8136 if r := recover(); r != nil {
8137 ec.Error(ctx, ec.Recover(ctx, r))
8138 ret = graphql.Null
8139 }
8140 }()
8141 fc := &graphql.FieldContext{
8142 Object: "PageInfo",
8143 Field: field,
8144 Args: nil,
8145 IsMethod: false,
8146 }
8147
8148 ctx = graphql.WithFieldContext(ctx, fc)
8149 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8150 ctx = rctx // use context from middleware stack in children
8151 return obj.HasNextPage, nil
8152 })
8153 if err != nil {
8154 ec.Error(ctx, err)
8155 return graphql.Null
8156 }
8157 if resTmp == nil {
8158 if !graphql.HasFieldError(ctx, fc) {
8159 ec.Errorf(ctx, "must not be null")
8160 }
8161 return graphql.Null
8162 }
8163 res := resTmp.(bool)
8164 fc.Result = res
8165 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
8166}
8167
8168func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8169 defer func() {
8170 if r := recover(); r != nil {
8171 ec.Error(ctx, ec.Recover(ctx, r))
8172 ret = graphql.Null
8173 }
8174 }()
8175 fc := &graphql.FieldContext{
8176 Object: "PageInfo",
8177 Field: field,
8178 Args: nil,
8179 IsMethod: false,
8180 }
8181
8182 ctx = graphql.WithFieldContext(ctx, fc)
8183 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8184 ctx = rctx // use context from middleware stack in children
8185 return obj.HasPreviousPage, nil
8186 })
8187 if err != nil {
8188 ec.Error(ctx, err)
8189 return graphql.Null
8190 }
8191 if resTmp == nil {
8192 if !graphql.HasFieldError(ctx, fc) {
8193 ec.Errorf(ctx, "must not be null")
8194 }
8195 return graphql.Null
8196 }
8197 res := resTmp.(bool)
8198 fc.Result = res
8199 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
8200}
8201
8202func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8203 defer func() {
8204 if r := recover(); r != nil {
8205 ec.Error(ctx, ec.Recover(ctx, r))
8206 ret = graphql.Null
8207 }
8208 }()
8209 fc := &graphql.FieldContext{
8210 Object: "PageInfo",
8211 Field: field,
8212 Args: nil,
8213 IsMethod: false,
8214 }
8215
8216 ctx = graphql.WithFieldContext(ctx, fc)
8217 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8218 ctx = rctx // use context from middleware stack in children
8219 return obj.StartCursor, nil
8220 })
8221 if err != nil {
8222 ec.Error(ctx, err)
8223 return graphql.Null
8224 }
8225 if resTmp == nil {
8226 if !graphql.HasFieldError(ctx, fc) {
8227 ec.Errorf(ctx, "must not be null")
8228 }
8229 return graphql.Null
8230 }
8231 res := resTmp.(string)
8232 fc.Result = res
8233 return ec.marshalNString2string(ctx, field.Selections, res)
8234}
8235
8236func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
8237 defer func() {
8238 if r := recover(); r != nil {
8239 ec.Error(ctx, ec.Recover(ctx, r))
8240 ret = graphql.Null
8241 }
8242 }()
8243 fc := &graphql.FieldContext{
8244 Object: "PageInfo",
8245 Field: field,
8246 Args: nil,
8247 IsMethod: false,
8248 }
8249
8250 ctx = graphql.WithFieldContext(ctx, fc)
8251 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8252 ctx = rctx // use context from middleware stack in children
8253 return obj.EndCursor, nil
8254 })
8255 if err != nil {
8256 ec.Error(ctx, err)
8257 return graphql.Null
8258 }
8259 if resTmp == nil {
8260 if !graphql.HasFieldError(ctx, fc) {
8261 ec.Errorf(ctx, "must not be null")
8262 }
8263 return graphql.Null
8264 }
8265 res := resTmp.(string)
8266 fc.Result = res
8267 return ec.marshalNString2string(ctx, field.Selections, res)
8268}
8269
8270func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8271 defer func() {
8272 if r := recover(); r != nil {
8273 ec.Error(ctx, ec.Recover(ctx, r))
8274 ret = graphql.Null
8275 }
8276 }()
8277 fc := &graphql.FieldContext{
8278 Object: "Query",
8279 Field: field,
8280 Args: nil,
8281 IsMethod: true,
8282 }
8283
8284 ctx = graphql.WithFieldContext(ctx, fc)
8285 rawArgs := field.ArgumentMap(ec.Variables)
8286 args, err := ec.field_Query_repository_args(ctx, rawArgs)
8287 if err != nil {
8288 ec.Error(ctx, err)
8289 return graphql.Null
8290 }
8291 fc.Args = args
8292 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8293 ctx = rctx // use context from middleware stack in children
8294 return ec.resolvers.Query().Repository(rctx, args["ref"].(*string))
8295 })
8296 if err != nil {
8297 ec.Error(ctx, err)
8298 return graphql.Null
8299 }
8300 if resTmp == nil {
8301 return graphql.Null
8302 }
8303 res := resTmp.(*models.Repository)
8304 fc.Result = res
8305 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
8306}
8307
8308func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8309 defer func() {
8310 if r := recover(); r != nil {
8311 ec.Error(ctx, ec.Recover(ctx, r))
8312 ret = graphql.Null
8313 }
8314 }()
8315 fc := &graphql.FieldContext{
8316 Object: "Query",
8317 Field: field,
8318 Args: nil,
8319 IsMethod: true,
8320 }
8321
8322 ctx = graphql.WithFieldContext(ctx, fc)
8323 rawArgs := field.ArgumentMap(ec.Variables)
8324 args, err := ec.field_Query___type_args(ctx, rawArgs)
8325 if err != nil {
8326 ec.Error(ctx, err)
8327 return graphql.Null
8328 }
8329 fc.Args = args
8330 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8331 ctx = rctx // use context from middleware stack in children
8332 return ec.introspectType(args["name"].(string))
8333 })
8334 if err != nil {
8335 ec.Error(ctx, err)
8336 return graphql.Null
8337 }
8338 if resTmp == nil {
8339 return graphql.Null
8340 }
8341 res := resTmp.(*introspection.Type)
8342 fc.Result = res
8343 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
8344}
8345
8346func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8347 defer func() {
8348 if r := recover(); r != nil {
8349 ec.Error(ctx, ec.Recover(ctx, r))
8350 ret = graphql.Null
8351 }
8352 }()
8353 fc := &graphql.FieldContext{
8354 Object: "Query",
8355 Field: field,
8356 Args: nil,
8357 IsMethod: true,
8358 }
8359
8360 ctx = graphql.WithFieldContext(ctx, fc)
8361 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8362 ctx = rctx // use context from middleware stack in children
8363 return ec.introspectSchema()
8364 })
8365 if err != nil {
8366 ec.Error(ctx, err)
8367 return graphql.Null
8368 }
8369 if resTmp == nil {
8370 return graphql.Null
8371 }
8372 res := resTmp.(*introspection.Schema)
8373 fc.Result = res
8374 return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
8375}
8376
8377func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8378 defer func() {
8379 if r := recover(); r != nil {
8380 ec.Error(ctx, ec.Recover(ctx, r))
8381 ret = graphql.Null
8382 }
8383 }()
8384 fc := &graphql.FieldContext{
8385 Object: "Repository",
8386 Field: field,
8387 Args: nil,
8388 IsMethod: true,
8389 }
8390
8391 ctx = graphql.WithFieldContext(ctx, fc)
8392 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8393 ctx = rctx // use context from middleware stack in children
8394 return ec.resolvers.Repository().Name(rctx, obj)
8395 })
8396 if err != nil {
8397 ec.Error(ctx, err)
8398 return graphql.Null
8399 }
8400 if resTmp == nil {
8401 return graphql.Null
8402 }
8403 res := resTmp.(*string)
8404 fc.Result = res
8405 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
8406}
8407
8408func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8409 defer func() {
8410 if r := recover(); r != nil {
8411 ec.Error(ctx, ec.Recover(ctx, r))
8412 ret = graphql.Null
8413 }
8414 }()
8415 fc := &graphql.FieldContext{
8416 Object: "Repository",
8417 Field: field,
8418 Args: nil,
8419 IsMethod: true,
8420 }
8421
8422 ctx = graphql.WithFieldContext(ctx, fc)
8423 rawArgs := field.ArgumentMap(ec.Variables)
8424 args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
8425 if err != nil {
8426 ec.Error(ctx, err)
8427 return graphql.Null
8428 }
8429 fc.Args = args
8430 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8431 ctx = rctx // use context from middleware stack in children
8432 return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
8433 })
8434 if err != nil {
8435 ec.Error(ctx, err)
8436 return graphql.Null
8437 }
8438 if resTmp == nil {
8439 if !graphql.HasFieldError(ctx, fc) {
8440 ec.Errorf(ctx, "must not be null")
8441 }
8442 return graphql.Null
8443 }
8444 res := resTmp.(*models.BugConnection)
8445 fc.Result = res
8446 return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
8447}
8448
8449func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8450 defer func() {
8451 if r := recover(); r != nil {
8452 ec.Error(ctx, ec.Recover(ctx, r))
8453 ret = graphql.Null
8454 }
8455 }()
8456 fc := &graphql.FieldContext{
8457 Object: "Repository",
8458 Field: field,
8459 Args: nil,
8460 IsMethod: true,
8461 }
8462
8463 ctx = graphql.WithFieldContext(ctx, fc)
8464 rawArgs := field.ArgumentMap(ec.Variables)
8465 args, err := ec.field_Repository_bug_args(ctx, rawArgs)
8466 if err != nil {
8467 ec.Error(ctx, err)
8468 return graphql.Null
8469 }
8470 fc.Args = args
8471 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8472 ctx = rctx // use context from middleware stack in children
8473 return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
8474 })
8475 if err != nil {
8476 ec.Error(ctx, err)
8477 return graphql.Null
8478 }
8479 if resTmp == nil {
8480 return graphql.Null
8481 }
8482 res := resTmp.(models.BugWrapper)
8483 fc.Result = res
8484 return ec.marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
8485}
8486
8487func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8488 defer func() {
8489 if r := recover(); r != nil {
8490 ec.Error(ctx, ec.Recover(ctx, r))
8491 ret = graphql.Null
8492 }
8493 }()
8494 fc := &graphql.FieldContext{
8495 Object: "Repository",
8496 Field: field,
8497 Args: nil,
8498 IsMethod: true,
8499 }
8500
8501 ctx = graphql.WithFieldContext(ctx, fc)
8502 rawArgs := field.ArgumentMap(ec.Variables)
8503 args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
8504 if err != nil {
8505 ec.Error(ctx, err)
8506 return graphql.Null
8507 }
8508 fc.Args = args
8509 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8510 ctx = rctx // use context from middleware stack in children
8511 return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8512 })
8513 if err != nil {
8514 ec.Error(ctx, err)
8515 return graphql.Null
8516 }
8517 if resTmp == nil {
8518 if !graphql.HasFieldError(ctx, fc) {
8519 ec.Errorf(ctx, "must not be null")
8520 }
8521 return graphql.Null
8522 }
8523 res := resTmp.(*models.IdentityConnection)
8524 fc.Result = res
8525 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
8526}
8527
8528func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8529 defer func() {
8530 if r := recover(); r != nil {
8531 ec.Error(ctx, ec.Recover(ctx, r))
8532 ret = graphql.Null
8533 }
8534 }()
8535 fc := &graphql.FieldContext{
8536 Object: "Repository",
8537 Field: field,
8538 Args: nil,
8539 IsMethod: true,
8540 }
8541
8542 ctx = graphql.WithFieldContext(ctx, fc)
8543 rawArgs := field.ArgumentMap(ec.Variables)
8544 args, err := ec.field_Repository_identity_args(ctx, rawArgs)
8545 if err != nil {
8546 ec.Error(ctx, err)
8547 return graphql.Null
8548 }
8549 fc.Args = args
8550 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8551 ctx = rctx // use context from middleware stack in children
8552 return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
8553 })
8554 if err != nil {
8555 ec.Error(ctx, err)
8556 return graphql.Null
8557 }
8558 if resTmp == nil {
8559 return graphql.Null
8560 }
8561 res := resTmp.(models.IdentityWrapper)
8562 fc.Result = res
8563 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8564}
8565
8566func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8567 defer func() {
8568 if r := recover(); r != nil {
8569 ec.Error(ctx, ec.Recover(ctx, r))
8570 ret = graphql.Null
8571 }
8572 }()
8573 fc := &graphql.FieldContext{
8574 Object: "Repository",
8575 Field: field,
8576 Args: nil,
8577 IsMethod: true,
8578 }
8579
8580 ctx = graphql.WithFieldContext(ctx, fc)
8581 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8582 ctx = rctx // use context from middleware stack in children
8583 return ec.resolvers.Repository().UserIdentity(rctx, obj)
8584 })
8585 if err != nil {
8586 ec.Error(ctx, err)
8587 return graphql.Null
8588 }
8589 if resTmp == nil {
8590 return graphql.Null
8591 }
8592 res := resTmp.(models.IdentityWrapper)
8593 fc.Result = res
8594 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8595}
8596
8597func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8598 defer func() {
8599 if r := recover(); r != nil {
8600 ec.Error(ctx, ec.Recover(ctx, r))
8601 ret = graphql.Null
8602 }
8603 }()
8604 fc := &graphql.FieldContext{
8605 Object: "Repository",
8606 Field: field,
8607 Args: nil,
8608 IsMethod: true,
8609 }
8610
8611 ctx = graphql.WithFieldContext(ctx, fc)
8612 rawArgs := field.ArgumentMap(ec.Variables)
8613 args, err := ec.field_Repository_validLabels_args(ctx, rawArgs)
8614 if err != nil {
8615 ec.Error(ctx, err)
8616 return graphql.Null
8617 }
8618 fc.Args = args
8619 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8620 ctx = rctx // use context from middleware stack in children
8621 return ec.resolvers.Repository().ValidLabels(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8622 })
8623 if err != nil {
8624 ec.Error(ctx, err)
8625 return graphql.Null
8626 }
8627 if resTmp == nil {
8628 if !graphql.HasFieldError(ctx, fc) {
8629 ec.Errorf(ctx, "must not be null")
8630 }
8631 return graphql.Null
8632 }
8633 res := resTmp.(*models.LabelConnection)
8634 fc.Result = res
8635 return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
8636}
8637
8638func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8639 defer func() {
8640 if r := recover(); r != nil {
8641 ec.Error(ctx, ec.Recover(ctx, r))
8642 ret = graphql.Null
8643 }
8644 }()
8645 fc := &graphql.FieldContext{
8646 Object: "SetStatusOperation",
8647 Field: field,
8648 Args: nil,
8649 IsMethod: true,
8650 }
8651
8652 ctx = graphql.WithFieldContext(ctx, fc)
8653 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8654 ctx = rctx // use context from middleware stack in children
8655 return ec.resolvers.SetStatusOperation().ID(rctx, obj)
8656 })
8657 if err != nil {
8658 ec.Error(ctx, err)
8659 return graphql.Null
8660 }
8661 if resTmp == nil {
8662 if !graphql.HasFieldError(ctx, fc) {
8663 ec.Errorf(ctx, "must not be null")
8664 }
8665 return graphql.Null
8666 }
8667 res := resTmp.(string)
8668 fc.Result = res
8669 return ec.marshalNString2string(ctx, field.Selections, res)
8670}
8671
8672func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8673 defer func() {
8674 if r := recover(); r != nil {
8675 ec.Error(ctx, ec.Recover(ctx, r))
8676 ret = graphql.Null
8677 }
8678 }()
8679 fc := &graphql.FieldContext{
8680 Object: "SetStatusOperation",
8681 Field: field,
8682 Args: nil,
8683 IsMethod: true,
8684 }
8685
8686 ctx = graphql.WithFieldContext(ctx, fc)
8687 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8688 ctx = rctx // use context from middleware stack in children
8689 return ec.resolvers.SetStatusOperation().Author(rctx, obj)
8690 })
8691 if err != nil {
8692 ec.Error(ctx, err)
8693 return graphql.Null
8694 }
8695 if resTmp == nil {
8696 if !graphql.HasFieldError(ctx, fc) {
8697 ec.Errorf(ctx, "must not be null")
8698 }
8699 return graphql.Null
8700 }
8701 res := resTmp.(models.IdentityWrapper)
8702 fc.Result = res
8703 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8704}
8705
8706func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8707 defer func() {
8708 if r := recover(); r != nil {
8709 ec.Error(ctx, ec.Recover(ctx, r))
8710 ret = graphql.Null
8711 }
8712 }()
8713 fc := &graphql.FieldContext{
8714 Object: "SetStatusOperation",
8715 Field: field,
8716 Args: nil,
8717 IsMethod: true,
8718 }
8719
8720 ctx = graphql.WithFieldContext(ctx, fc)
8721 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8722 ctx = rctx // use context from middleware stack in children
8723 return ec.resolvers.SetStatusOperation().Date(rctx, obj)
8724 })
8725 if err != nil {
8726 ec.Error(ctx, err)
8727 return graphql.Null
8728 }
8729 if resTmp == nil {
8730 if !graphql.HasFieldError(ctx, fc) {
8731 ec.Errorf(ctx, "must not be null")
8732 }
8733 return graphql.Null
8734 }
8735 res := resTmp.(*time.Time)
8736 fc.Result = res
8737 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8738}
8739
8740func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8741 defer func() {
8742 if r := recover(); r != nil {
8743 ec.Error(ctx, ec.Recover(ctx, r))
8744 ret = graphql.Null
8745 }
8746 }()
8747 fc := &graphql.FieldContext{
8748 Object: "SetStatusOperation",
8749 Field: field,
8750 Args: nil,
8751 IsMethod: true,
8752 }
8753
8754 ctx = graphql.WithFieldContext(ctx, fc)
8755 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8756 ctx = rctx // use context from middleware stack in children
8757 return ec.resolvers.SetStatusOperation().Status(rctx, obj)
8758 })
8759 if err != nil {
8760 ec.Error(ctx, err)
8761 return graphql.Null
8762 }
8763 if resTmp == nil {
8764 if !graphql.HasFieldError(ctx, fc) {
8765 ec.Errorf(ctx, "must not be null")
8766 }
8767 return graphql.Null
8768 }
8769 res := resTmp.(models.Status)
8770 fc.Result = res
8771 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8772}
8773
8774func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8775 defer func() {
8776 if r := recover(); r != nil {
8777 ec.Error(ctx, ec.Recover(ctx, r))
8778 ret = graphql.Null
8779 }
8780 }()
8781 fc := &graphql.FieldContext{
8782 Object: "SetStatusTimelineItem",
8783 Field: field,
8784 Args: nil,
8785 IsMethod: true,
8786 }
8787
8788 ctx = graphql.WithFieldContext(ctx, fc)
8789 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8790 ctx = rctx // use context from middleware stack in children
8791 return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
8792 })
8793 if err != nil {
8794 ec.Error(ctx, err)
8795 return graphql.Null
8796 }
8797 if resTmp == nil {
8798 if !graphql.HasFieldError(ctx, fc) {
8799 ec.Errorf(ctx, "must not be null")
8800 }
8801 return graphql.Null
8802 }
8803 res := resTmp.(string)
8804 fc.Result = res
8805 return ec.marshalNString2string(ctx, field.Selections, res)
8806}
8807
8808func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8809 defer func() {
8810 if r := recover(); r != nil {
8811 ec.Error(ctx, ec.Recover(ctx, r))
8812 ret = graphql.Null
8813 }
8814 }()
8815 fc := &graphql.FieldContext{
8816 Object: "SetStatusTimelineItem",
8817 Field: field,
8818 Args: nil,
8819 IsMethod: true,
8820 }
8821
8822 ctx = graphql.WithFieldContext(ctx, fc)
8823 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8824 ctx = rctx // use context from middleware stack in children
8825 return ec.resolvers.SetStatusTimelineItem().Author(rctx, obj)
8826 })
8827 if err != nil {
8828 ec.Error(ctx, err)
8829 return graphql.Null
8830 }
8831 if resTmp == nil {
8832 if !graphql.HasFieldError(ctx, fc) {
8833 ec.Errorf(ctx, "must not be null")
8834 }
8835 return graphql.Null
8836 }
8837 res := resTmp.(models.IdentityWrapper)
8838 fc.Result = res
8839 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8840}
8841
8842func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8843 defer func() {
8844 if r := recover(); r != nil {
8845 ec.Error(ctx, ec.Recover(ctx, r))
8846 ret = graphql.Null
8847 }
8848 }()
8849 fc := &graphql.FieldContext{
8850 Object: "SetStatusTimelineItem",
8851 Field: field,
8852 Args: nil,
8853 IsMethod: true,
8854 }
8855
8856 ctx = graphql.WithFieldContext(ctx, fc)
8857 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8858 ctx = rctx // use context from middleware stack in children
8859 return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
8860 })
8861 if err != nil {
8862 ec.Error(ctx, err)
8863 return graphql.Null
8864 }
8865 if resTmp == nil {
8866 if !graphql.HasFieldError(ctx, fc) {
8867 ec.Errorf(ctx, "must not be null")
8868 }
8869 return graphql.Null
8870 }
8871 res := resTmp.(*time.Time)
8872 fc.Result = res
8873 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8874}
8875
8876func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8877 defer func() {
8878 if r := recover(); r != nil {
8879 ec.Error(ctx, ec.Recover(ctx, r))
8880 ret = graphql.Null
8881 }
8882 }()
8883 fc := &graphql.FieldContext{
8884 Object: "SetStatusTimelineItem",
8885 Field: field,
8886 Args: nil,
8887 IsMethod: true,
8888 }
8889
8890 ctx = graphql.WithFieldContext(ctx, fc)
8891 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8892 ctx = rctx // use context from middleware stack in children
8893 return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
8894 })
8895 if err != nil {
8896 ec.Error(ctx, err)
8897 return graphql.Null
8898 }
8899 if resTmp == nil {
8900 if !graphql.HasFieldError(ctx, fc) {
8901 ec.Errorf(ctx, "must not be null")
8902 }
8903 return graphql.Null
8904 }
8905 res := resTmp.(models.Status)
8906 fc.Result = res
8907 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8908}
8909
8910func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8911 defer func() {
8912 if r := recover(); r != nil {
8913 ec.Error(ctx, ec.Recover(ctx, r))
8914 ret = graphql.Null
8915 }
8916 }()
8917 fc := &graphql.FieldContext{
8918 Object: "SetTitleOperation",
8919 Field: field,
8920 Args: nil,
8921 IsMethod: true,
8922 }
8923
8924 ctx = graphql.WithFieldContext(ctx, fc)
8925 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8926 ctx = rctx // use context from middleware stack in children
8927 return ec.resolvers.SetTitleOperation().ID(rctx, obj)
8928 })
8929 if err != nil {
8930 ec.Error(ctx, err)
8931 return graphql.Null
8932 }
8933 if resTmp == nil {
8934 if !graphql.HasFieldError(ctx, fc) {
8935 ec.Errorf(ctx, "must not be null")
8936 }
8937 return graphql.Null
8938 }
8939 res := resTmp.(string)
8940 fc.Result = res
8941 return ec.marshalNString2string(ctx, field.Selections, res)
8942}
8943
8944func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8945 defer func() {
8946 if r := recover(); r != nil {
8947 ec.Error(ctx, ec.Recover(ctx, r))
8948 ret = graphql.Null
8949 }
8950 }()
8951 fc := &graphql.FieldContext{
8952 Object: "SetTitleOperation",
8953 Field: field,
8954 Args: nil,
8955 IsMethod: true,
8956 }
8957
8958 ctx = graphql.WithFieldContext(ctx, fc)
8959 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8960 ctx = rctx // use context from middleware stack in children
8961 return ec.resolvers.SetTitleOperation().Author(rctx, obj)
8962 })
8963 if err != nil {
8964 ec.Error(ctx, err)
8965 return graphql.Null
8966 }
8967 if resTmp == nil {
8968 if !graphql.HasFieldError(ctx, fc) {
8969 ec.Errorf(ctx, "must not be null")
8970 }
8971 return graphql.Null
8972 }
8973 res := resTmp.(models.IdentityWrapper)
8974 fc.Result = res
8975 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8976}
8977
8978func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
8979 defer func() {
8980 if r := recover(); r != nil {
8981 ec.Error(ctx, ec.Recover(ctx, r))
8982 ret = graphql.Null
8983 }
8984 }()
8985 fc := &graphql.FieldContext{
8986 Object: "SetTitleOperation",
8987 Field: field,
8988 Args: nil,
8989 IsMethod: true,
8990 }
8991
8992 ctx = graphql.WithFieldContext(ctx, fc)
8993 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8994 ctx = rctx // use context from middleware stack in children
8995 return ec.resolvers.SetTitleOperation().Date(rctx, obj)
8996 })
8997 if err != nil {
8998 ec.Error(ctx, err)
8999 return graphql.Null
9000 }
9001 if resTmp == nil {
9002 if !graphql.HasFieldError(ctx, fc) {
9003 ec.Errorf(ctx, "must not be null")
9004 }
9005 return graphql.Null
9006 }
9007 res := resTmp.(*time.Time)
9008 fc.Result = res
9009 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
9010}
9011
9012func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
9013 defer func() {
9014 if r := recover(); r != nil {
9015 ec.Error(ctx, ec.Recover(ctx, r))
9016 ret = graphql.Null
9017 }
9018 }()
9019 fc := &graphql.FieldContext{
9020 Object: "SetTitleOperation",
9021 Field: field,
9022 Args: nil,
9023 IsMethod: false,
9024 }
9025
9026 ctx = graphql.WithFieldContext(ctx, fc)
9027 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9028 ctx = rctx // use context from middleware stack in children
9029 return obj.Title, nil
9030 })
9031 if err != nil {
9032 ec.Error(ctx, err)
9033 return graphql.Null
9034 }
9035 if resTmp == nil {
9036 if !graphql.HasFieldError(ctx, fc) {
9037 ec.Errorf(ctx, "must not be null")
9038 }
9039 return graphql.Null
9040 }
9041 res := resTmp.(string)
9042 fc.Result = res
9043 return ec.marshalNString2string(ctx, field.Selections, res)
9044}
9045
9046func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
9047 defer func() {
9048 if r := recover(); r != nil {
9049 ec.Error(ctx, ec.Recover(ctx, r))
9050 ret = graphql.Null
9051 }
9052 }()
9053 fc := &graphql.FieldContext{
9054 Object: "SetTitleOperation",
9055 Field: field,
9056 Args: nil,
9057 IsMethod: false,
9058 }
9059
9060 ctx = graphql.WithFieldContext(ctx, fc)
9061 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9062 ctx = rctx // use context from middleware stack in children
9063 return obj.Was, nil
9064 })
9065 if err != nil {
9066 ec.Error(ctx, err)
9067 return graphql.Null
9068 }
9069 if resTmp == nil {
9070 if !graphql.HasFieldError(ctx, fc) {
9071 ec.Errorf(ctx, "must not be null")
9072 }
9073 return graphql.Null
9074 }
9075 res := resTmp.(string)
9076 fc.Result = res
9077 return ec.marshalNString2string(ctx, field.Selections, res)
9078}
9079
9080func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
9081 defer func() {
9082 if r := recover(); r != nil {
9083 ec.Error(ctx, ec.Recover(ctx, r))
9084 ret = graphql.Null
9085 }
9086 }()
9087 fc := &graphql.FieldContext{
9088 Object: "SetTitlePayload",
9089 Field: field,
9090 Args: nil,
9091 IsMethod: false,
9092 }
9093
9094 ctx = graphql.WithFieldContext(ctx, fc)
9095 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9096 ctx = rctx // use context from middleware stack in children
9097 return obj.ClientMutationID, nil
9098 })
9099 if err != nil {
9100 ec.Error(ctx, err)
9101 return graphql.Null
9102 }
9103 if resTmp == nil {
9104 return graphql.Null
9105 }
9106 res := resTmp.(*string)
9107 fc.Result = res
9108 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9109}
9110
9111func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
9112 defer func() {
9113 if r := recover(); r != nil {
9114 ec.Error(ctx, ec.Recover(ctx, r))
9115 ret = graphql.Null
9116 }
9117 }()
9118 fc := &graphql.FieldContext{
9119 Object: "SetTitlePayload",
9120 Field: field,
9121 Args: nil,
9122 IsMethod: false,
9123 }
9124
9125 ctx = graphql.WithFieldContext(ctx, fc)
9126 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9127 ctx = rctx // use context from middleware stack in children
9128 return obj.Bug, nil
9129 })
9130 if err != nil {
9131 ec.Error(ctx, err)
9132 return graphql.Null
9133 }
9134 if resTmp == nil {
9135 if !graphql.HasFieldError(ctx, fc) {
9136 ec.Errorf(ctx, "must not be null")
9137 }
9138 return graphql.Null
9139 }
9140 res := resTmp.(models.BugWrapper)
9141 fc.Result = res
9142 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
9143}
9144
9145func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
9146 defer func() {
9147 if r := recover(); r != nil {
9148 ec.Error(ctx, ec.Recover(ctx, r))
9149 ret = graphql.Null
9150 }
9151 }()
9152 fc := &graphql.FieldContext{
9153 Object: "SetTitlePayload",
9154 Field: field,
9155 Args: nil,
9156 IsMethod: false,
9157 }
9158
9159 ctx = graphql.WithFieldContext(ctx, fc)
9160 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9161 ctx = rctx // use context from middleware stack in children
9162 return obj.Operation, nil
9163 })
9164 if err != nil {
9165 ec.Error(ctx, err)
9166 return graphql.Null
9167 }
9168 if resTmp == nil {
9169 if !graphql.HasFieldError(ctx, fc) {
9170 ec.Errorf(ctx, "must not be null")
9171 }
9172 return graphql.Null
9173 }
9174 res := resTmp.(*bug.SetTitleOperation)
9175 fc.Result = res
9176 return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
9177}
9178
9179func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9180 defer func() {
9181 if r := recover(); r != nil {
9182 ec.Error(ctx, ec.Recover(ctx, r))
9183 ret = graphql.Null
9184 }
9185 }()
9186 fc := &graphql.FieldContext{
9187 Object: "SetTitleTimelineItem",
9188 Field: field,
9189 Args: nil,
9190 IsMethod: true,
9191 }
9192
9193 ctx = graphql.WithFieldContext(ctx, fc)
9194 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9195 ctx = rctx // use context from middleware stack in children
9196 return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
9197 })
9198 if err != nil {
9199 ec.Error(ctx, err)
9200 return graphql.Null
9201 }
9202 if resTmp == nil {
9203 if !graphql.HasFieldError(ctx, fc) {
9204 ec.Errorf(ctx, "must not be null")
9205 }
9206 return graphql.Null
9207 }
9208 res := resTmp.(string)
9209 fc.Result = res
9210 return ec.marshalNString2string(ctx, field.Selections, res)
9211}
9212
9213func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9214 defer func() {
9215 if r := recover(); r != nil {
9216 ec.Error(ctx, ec.Recover(ctx, r))
9217 ret = graphql.Null
9218 }
9219 }()
9220 fc := &graphql.FieldContext{
9221 Object: "SetTitleTimelineItem",
9222 Field: field,
9223 Args: nil,
9224 IsMethod: true,
9225 }
9226
9227 ctx = graphql.WithFieldContext(ctx, fc)
9228 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9229 ctx = rctx // use context from middleware stack in children
9230 return ec.resolvers.SetTitleTimelineItem().Author(rctx, obj)
9231 })
9232 if err != nil {
9233 ec.Error(ctx, err)
9234 return graphql.Null
9235 }
9236 if resTmp == nil {
9237 if !graphql.HasFieldError(ctx, fc) {
9238 ec.Errorf(ctx, "must not be null")
9239 }
9240 return graphql.Null
9241 }
9242 res := resTmp.(models.IdentityWrapper)
9243 fc.Result = res
9244 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
9245}
9246
9247func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9248 defer func() {
9249 if r := recover(); r != nil {
9250 ec.Error(ctx, ec.Recover(ctx, r))
9251 ret = graphql.Null
9252 }
9253 }()
9254 fc := &graphql.FieldContext{
9255 Object: "SetTitleTimelineItem",
9256 Field: field,
9257 Args: nil,
9258 IsMethod: true,
9259 }
9260
9261 ctx = graphql.WithFieldContext(ctx, fc)
9262 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9263 ctx = rctx // use context from middleware stack in children
9264 return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
9265 })
9266 if err != nil {
9267 ec.Error(ctx, err)
9268 return graphql.Null
9269 }
9270 if resTmp == nil {
9271 if !graphql.HasFieldError(ctx, fc) {
9272 ec.Errorf(ctx, "must not be null")
9273 }
9274 return graphql.Null
9275 }
9276 res := resTmp.(*time.Time)
9277 fc.Result = res
9278 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
9279}
9280
9281func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9282 defer func() {
9283 if r := recover(); r != nil {
9284 ec.Error(ctx, ec.Recover(ctx, r))
9285 ret = graphql.Null
9286 }
9287 }()
9288 fc := &graphql.FieldContext{
9289 Object: "SetTitleTimelineItem",
9290 Field: field,
9291 Args: nil,
9292 IsMethod: false,
9293 }
9294
9295 ctx = graphql.WithFieldContext(ctx, fc)
9296 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9297 ctx = rctx // use context from middleware stack in children
9298 return obj.Title, nil
9299 })
9300 if err != nil {
9301 ec.Error(ctx, err)
9302 return graphql.Null
9303 }
9304 if resTmp == nil {
9305 if !graphql.HasFieldError(ctx, fc) {
9306 ec.Errorf(ctx, "must not be null")
9307 }
9308 return graphql.Null
9309 }
9310 res := resTmp.(string)
9311 fc.Result = res
9312 return ec.marshalNString2string(ctx, field.Selections, res)
9313}
9314
9315func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9316 defer func() {
9317 if r := recover(); r != nil {
9318 ec.Error(ctx, ec.Recover(ctx, r))
9319 ret = graphql.Null
9320 }
9321 }()
9322 fc := &graphql.FieldContext{
9323 Object: "SetTitleTimelineItem",
9324 Field: field,
9325 Args: nil,
9326 IsMethod: false,
9327 }
9328
9329 ctx = graphql.WithFieldContext(ctx, fc)
9330 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9331 ctx = rctx // use context from middleware stack in children
9332 return obj.Was, nil
9333 })
9334 if err != nil {
9335 ec.Error(ctx, err)
9336 return graphql.Null
9337 }
9338 if resTmp == nil {
9339 if !graphql.HasFieldError(ctx, fc) {
9340 ec.Errorf(ctx, "must not be null")
9341 }
9342 return graphql.Null
9343 }
9344 res := resTmp.(string)
9345 fc.Result = res
9346 return ec.marshalNString2string(ctx, field.Selections, res)
9347}
9348
9349func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9350 defer func() {
9351 if r := recover(); r != nil {
9352 ec.Error(ctx, ec.Recover(ctx, r))
9353 ret = graphql.Null
9354 }
9355 }()
9356 fc := &graphql.FieldContext{
9357 Object: "TimelineItemConnection",
9358 Field: field,
9359 Args: nil,
9360 IsMethod: false,
9361 }
9362
9363 ctx = graphql.WithFieldContext(ctx, fc)
9364 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9365 ctx = rctx // use context from middleware stack in children
9366 return obj.Edges, nil
9367 })
9368 if err != nil {
9369 ec.Error(ctx, err)
9370 return graphql.Null
9371 }
9372 if resTmp == nil {
9373 if !graphql.HasFieldError(ctx, fc) {
9374 ec.Errorf(ctx, "must not be null")
9375 }
9376 return graphql.Null
9377 }
9378 res := resTmp.([]*models.TimelineItemEdge)
9379 fc.Result = res
9380 return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx, field.Selections, res)
9381}
9382
9383func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9384 defer func() {
9385 if r := recover(); r != nil {
9386 ec.Error(ctx, ec.Recover(ctx, r))
9387 ret = graphql.Null
9388 }
9389 }()
9390 fc := &graphql.FieldContext{
9391 Object: "TimelineItemConnection",
9392 Field: field,
9393 Args: nil,
9394 IsMethod: false,
9395 }
9396
9397 ctx = graphql.WithFieldContext(ctx, fc)
9398 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9399 ctx = rctx // use context from middleware stack in children
9400 return obj.Nodes, nil
9401 })
9402 if err != nil {
9403 ec.Error(ctx, err)
9404 return graphql.Null
9405 }
9406 if resTmp == nil {
9407 if !graphql.HasFieldError(ctx, fc) {
9408 ec.Errorf(ctx, "must not be null")
9409 }
9410 return graphql.Null
9411 }
9412 res := resTmp.([]bug.TimelineItem)
9413 fc.Result = res
9414 return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx, field.Selections, res)
9415}
9416
9417func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9418 defer func() {
9419 if r := recover(); r != nil {
9420 ec.Error(ctx, ec.Recover(ctx, r))
9421 ret = graphql.Null
9422 }
9423 }()
9424 fc := &graphql.FieldContext{
9425 Object: "TimelineItemConnection",
9426 Field: field,
9427 Args: nil,
9428 IsMethod: false,
9429 }
9430
9431 ctx = graphql.WithFieldContext(ctx, fc)
9432 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9433 ctx = rctx // use context from middleware stack in children
9434 return obj.PageInfo, nil
9435 })
9436 if err != nil {
9437 ec.Error(ctx, err)
9438 return graphql.Null
9439 }
9440 if resTmp == nil {
9441 if !graphql.HasFieldError(ctx, fc) {
9442 ec.Errorf(ctx, "must not be null")
9443 }
9444 return graphql.Null
9445 }
9446 res := resTmp.(*models.PageInfo)
9447 fc.Result = res
9448 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
9449}
9450
9451func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9452 defer func() {
9453 if r := recover(); r != nil {
9454 ec.Error(ctx, ec.Recover(ctx, r))
9455 ret = graphql.Null
9456 }
9457 }()
9458 fc := &graphql.FieldContext{
9459 Object: "TimelineItemConnection",
9460 Field: field,
9461 Args: nil,
9462 IsMethod: false,
9463 }
9464
9465 ctx = graphql.WithFieldContext(ctx, fc)
9466 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9467 ctx = rctx // use context from middleware stack in children
9468 return obj.TotalCount, nil
9469 })
9470 if err != nil {
9471 ec.Error(ctx, err)
9472 return graphql.Null
9473 }
9474 if resTmp == nil {
9475 if !graphql.HasFieldError(ctx, fc) {
9476 ec.Errorf(ctx, "must not be null")
9477 }
9478 return graphql.Null
9479 }
9480 res := resTmp.(int)
9481 fc.Result = res
9482 return ec.marshalNInt2int(ctx, field.Selections, res)
9483}
9484
9485func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9486 defer func() {
9487 if r := recover(); r != nil {
9488 ec.Error(ctx, ec.Recover(ctx, r))
9489 ret = graphql.Null
9490 }
9491 }()
9492 fc := &graphql.FieldContext{
9493 Object: "TimelineItemEdge",
9494 Field: field,
9495 Args: nil,
9496 IsMethod: false,
9497 }
9498
9499 ctx = graphql.WithFieldContext(ctx, fc)
9500 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9501 ctx = rctx // use context from middleware stack in children
9502 return obj.Cursor, nil
9503 })
9504 if err != nil {
9505 ec.Error(ctx, err)
9506 return graphql.Null
9507 }
9508 if resTmp == nil {
9509 if !graphql.HasFieldError(ctx, fc) {
9510 ec.Errorf(ctx, "must not be null")
9511 }
9512 return graphql.Null
9513 }
9514 res := resTmp.(string)
9515 fc.Result = res
9516 return ec.marshalNString2string(ctx, field.Selections, res)
9517}
9518
9519func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9520 defer func() {
9521 if r := recover(); r != nil {
9522 ec.Error(ctx, ec.Recover(ctx, r))
9523 ret = graphql.Null
9524 }
9525 }()
9526 fc := &graphql.FieldContext{
9527 Object: "TimelineItemEdge",
9528 Field: field,
9529 Args: nil,
9530 IsMethod: false,
9531 }
9532
9533 ctx = graphql.WithFieldContext(ctx, fc)
9534 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9535 ctx = rctx // use context from middleware stack in children
9536 return obj.Node, nil
9537 })
9538 if err != nil {
9539 ec.Error(ctx, err)
9540 return graphql.Null
9541 }
9542 if resTmp == nil {
9543 if !graphql.HasFieldError(ctx, fc) {
9544 ec.Errorf(ctx, "must not be null")
9545 }
9546 return graphql.Null
9547 }
9548 res := resTmp.(bug.TimelineItem)
9549 fc.Result = res
9550 return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
9551}
9552
9553func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9554 defer func() {
9555 if r := recover(); r != nil {
9556 ec.Error(ctx, ec.Recover(ctx, r))
9557 ret = graphql.Null
9558 }
9559 }()
9560 fc := &graphql.FieldContext{
9561 Object: "__Directive",
9562 Field: field,
9563 Args: nil,
9564 IsMethod: false,
9565 }
9566
9567 ctx = graphql.WithFieldContext(ctx, fc)
9568 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9569 ctx = rctx // use context from middleware stack in children
9570 return obj.Name, nil
9571 })
9572 if err != nil {
9573 ec.Error(ctx, err)
9574 return graphql.Null
9575 }
9576 if resTmp == nil {
9577 if !graphql.HasFieldError(ctx, fc) {
9578 ec.Errorf(ctx, "must not be null")
9579 }
9580 return graphql.Null
9581 }
9582 res := resTmp.(string)
9583 fc.Result = res
9584 return ec.marshalNString2string(ctx, field.Selections, res)
9585}
9586
9587func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9588 defer func() {
9589 if r := recover(); r != nil {
9590 ec.Error(ctx, ec.Recover(ctx, r))
9591 ret = graphql.Null
9592 }
9593 }()
9594 fc := &graphql.FieldContext{
9595 Object: "__Directive",
9596 Field: field,
9597 Args: nil,
9598 IsMethod: false,
9599 }
9600
9601 ctx = graphql.WithFieldContext(ctx, fc)
9602 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9603 ctx = rctx // use context from middleware stack in children
9604 return obj.Description, nil
9605 })
9606 if err != nil {
9607 ec.Error(ctx, err)
9608 return graphql.Null
9609 }
9610 if resTmp == nil {
9611 return graphql.Null
9612 }
9613 res := resTmp.(string)
9614 fc.Result = res
9615 return ec.marshalOString2string(ctx, field.Selections, res)
9616}
9617
9618func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9619 defer func() {
9620 if r := recover(); r != nil {
9621 ec.Error(ctx, ec.Recover(ctx, r))
9622 ret = graphql.Null
9623 }
9624 }()
9625 fc := &graphql.FieldContext{
9626 Object: "__Directive",
9627 Field: field,
9628 Args: nil,
9629 IsMethod: false,
9630 }
9631
9632 ctx = graphql.WithFieldContext(ctx, fc)
9633 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9634 ctx = rctx // use context from middleware stack in children
9635 return obj.Locations, nil
9636 })
9637 if err != nil {
9638 ec.Error(ctx, err)
9639 return graphql.Null
9640 }
9641 if resTmp == nil {
9642 if !graphql.HasFieldError(ctx, fc) {
9643 ec.Errorf(ctx, "must not be null")
9644 }
9645 return graphql.Null
9646 }
9647 res := resTmp.([]string)
9648 fc.Result = res
9649 return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
9650}
9651
9652func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9653 defer func() {
9654 if r := recover(); r != nil {
9655 ec.Error(ctx, ec.Recover(ctx, r))
9656 ret = graphql.Null
9657 }
9658 }()
9659 fc := &graphql.FieldContext{
9660 Object: "__Directive",
9661 Field: field,
9662 Args: nil,
9663 IsMethod: false,
9664 }
9665
9666 ctx = graphql.WithFieldContext(ctx, fc)
9667 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9668 ctx = rctx // use context from middleware stack in children
9669 return obj.Args, nil
9670 })
9671 if err != nil {
9672 ec.Error(ctx, err)
9673 return graphql.Null
9674 }
9675 if resTmp == nil {
9676 if !graphql.HasFieldError(ctx, fc) {
9677 ec.Errorf(ctx, "must not be null")
9678 }
9679 return graphql.Null
9680 }
9681 res := resTmp.([]introspection.InputValue)
9682 fc.Result = res
9683 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
9684}
9685
9686func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9687 defer func() {
9688 if r := recover(); r != nil {
9689 ec.Error(ctx, ec.Recover(ctx, r))
9690 ret = graphql.Null
9691 }
9692 }()
9693 fc := &graphql.FieldContext{
9694 Object: "__EnumValue",
9695 Field: field,
9696 Args: nil,
9697 IsMethod: false,
9698 }
9699
9700 ctx = graphql.WithFieldContext(ctx, fc)
9701 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9702 ctx = rctx // use context from middleware stack in children
9703 return obj.Name, nil
9704 })
9705 if err != nil {
9706 ec.Error(ctx, err)
9707 return graphql.Null
9708 }
9709 if resTmp == nil {
9710 if !graphql.HasFieldError(ctx, fc) {
9711 ec.Errorf(ctx, "must not be null")
9712 }
9713 return graphql.Null
9714 }
9715 res := resTmp.(string)
9716 fc.Result = res
9717 return ec.marshalNString2string(ctx, field.Selections, res)
9718}
9719
9720func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9721 defer func() {
9722 if r := recover(); r != nil {
9723 ec.Error(ctx, ec.Recover(ctx, r))
9724 ret = graphql.Null
9725 }
9726 }()
9727 fc := &graphql.FieldContext{
9728 Object: "__EnumValue",
9729 Field: field,
9730 Args: nil,
9731 IsMethod: false,
9732 }
9733
9734 ctx = graphql.WithFieldContext(ctx, fc)
9735 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9736 ctx = rctx // use context from middleware stack in children
9737 return obj.Description, nil
9738 })
9739 if err != nil {
9740 ec.Error(ctx, err)
9741 return graphql.Null
9742 }
9743 if resTmp == nil {
9744 return graphql.Null
9745 }
9746 res := resTmp.(string)
9747 fc.Result = res
9748 return ec.marshalOString2string(ctx, field.Selections, res)
9749}
9750
9751func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (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: "__EnumValue",
9760 Field: field,
9761 Args: nil,
9762 IsMethod: true,
9763 }
9764
9765 ctx = graphql.WithFieldContext(ctx, fc)
9766 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9767 ctx = rctx // use context from middleware stack in children
9768 return obj.IsDeprecated(), nil
9769 })
9770 if err != nil {
9771 ec.Error(ctx, err)
9772 return graphql.Null
9773 }
9774 if resTmp == nil {
9775 if !graphql.HasFieldError(ctx, fc) {
9776 ec.Errorf(ctx, "must not be null")
9777 }
9778 return graphql.Null
9779 }
9780 res := resTmp.(bool)
9781 fc.Result = res
9782 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9783}
9784
9785func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9786 defer func() {
9787 if r := recover(); r != nil {
9788 ec.Error(ctx, ec.Recover(ctx, r))
9789 ret = graphql.Null
9790 }
9791 }()
9792 fc := &graphql.FieldContext{
9793 Object: "__EnumValue",
9794 Field: field,
9795 Args: nil,
9796 IsMethod: true,
9797 }
9798
9799 ctx = graphql.WithFieldContext(ctx, fc)
9800 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9801 ctx = rctx // use context from middleware stack in children
9802 return obj.DeprecationReason(), nil
9803 })
9804 if err != nil {
9805 ec.Error(ctx, err)
9806 return graphql.Null
9807 }
9808 if resTmp == nil {
9809 return graphql.Null
9810 }
9811 res := resTmp.(*string)
9812 fc.Result = res
9813 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9814}
9815
9816func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9817 defer func() {
9818 if r := recover(); r != nil {
9819 ec.Error(ctx, ec.Recover(ctx, r))
9820 ret = graphql.Null
9821 }
9822 }()
9823 fc := &graphql.FieldContext{
9824 Object: "__Field",
9825 Field: field,
9826 Args: nil,
9827 IsMethod: false,
9828 }
9829
9830 ctx = graphql.WithFieldContext(ctx, fc)
9831 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9832 ctx = rctx // use context from middleware stack in children
9833 return obj.Name, nil
9834 })
9835 if err != nil {
9836 ec.Error(ctx, err)
9837 return graphql.Null
9838 }
9839 if resTmp == nil {
9840 if !graphql.HasFieldError(ctx, fc) {
9841 ec.Errorf(ctx, "must not be null")
9842 }
9843 return graphql.Null
9844 }
9845 res := resTmp.(string)
9846 fc.Result = res
9847 return ec.marshalNString2string(ctx, field.Selections, res)
9848}
9849
9850func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9851 defer func() {
9852 if r := recover(); r != nil {
9853 ec.Error(ctx, ec.Recover(ctx, r))
9854 ret = graphql.Null
9855 }
9856 }()
9857 fc := &graphql.FieldContext{
9858 Object: "__Field",
9859 Field: field,
9860 Args: nil,
9861 IsMethod: false,
9862 }
9863
9864 ctx = graphql.WithFieldContext(ctx, fc)
9865 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9866 ctx = rctx // use context from middleware stack in children
9867 return obj.Description, nil
9868 })
9869 if err != nil {
9870 ec.Error(ctx, err)
9871 return graphql.Null
9872 }
9873 if resTmp == nil {
9874 return graphql.Null
9875 }
9876 res := resTmp.(string)
9877 fc.Result = res
9878 return ec.marshalOString2string(ctx, field.Selections, res)
9879}
9880
9881func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9882 defer func() {
9883 if r := recover(); r != nil {
9884 ec.Error(ctx, ec.Recover(ctx, r))
9885 ret = graphql.Null
9886 }
9887 }()
9888 fc := &graphql.FieldContext{
9889 Object: "__Field",
9890 Field: field,
9891 Args: nil,
9892 IsMethod: false,
9893 }
9894
9895 ctx = graphql.WithFieldContext(ctx, fc)
9896 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9897 ctx = rctx // use context from middleware stack in children
9898 return obj.Args, nil
9899 })
9900 if err != nil {
9901 ec.Error(ctx, err)
9902 return graphql.Null
9903 }
9904 if resTmp == nil {
9905 if !graphql.HasFieldError(ctx, fc) {
9906 ec.Errorf(ctx, "must not be null")
9907 }
9908 return graphql.Null
9909 }
9910 res := resTmp.([]introspection.InputValue)
9911 fc.Result = res
9912 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
9913}
9914
9915func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9916 defer func() {
9917 if r := recover(); r != nil {
9918 ec.Error(ctx, ec.Recover(ctx, r))
9919 ret = graphql.Null
9920 }
9921 }()
9922 fc := &graphql.FieldContext{
9923 Object: "__Field",
9924 Field: field,
9925 Args: nil,
9926 IsMethod: false,
9927 }
9928
9929 ctx = graphql.WithFieldContext(ctx, fc)
9930 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9931 ctx = rctx // use context from middleware stack in children
9932 return obj.Type, nil
9933 })
9934 if err != nil {
9935 ec.Error(ctx, err)
9936 return graphql.Null
9937 }
9938 if resTmp == nil {
9939 if !graphql.HasFieldError(ctx, fc) {
9940 ec.Errorf(ctx, "must not be null")
9941 }
9942 return graphql.Null
9943 }
9944 res := resTmp.(*introspection.Type)
9945 fc.Result = res
9946 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9947}
9948
9949func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9950 defer func() {
9951 if r := recover(); r != nil {
9952 ec.Error(ctx, ec.Recover(ctx, r))
9953 ret = graphql.Null
9954 }
9955 }()
9956 fc := &graphql.FieldContext{
9957 Object: "__Field",
9958 Field: field,
9959 Args: nil,
9960 IsMethod: true,
9961 }
9962
9963 ctx = graphql.WithFieldContext(ctx, fc)
9964 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9965 ctx = rctx // use context from middleware stack in children
9966 return obj.IsDeprecated(), nil
9967 })
9968 if err != nil {
9969 ec.Error(ctx, err)
9970 return graphql.Null
9971 }
9972 if resTmp == nil {
9973 if !graphql.HasFieldError(ctx, fc) {
9974 ec.Errorf(ctx, "must not be null")
9975 }
9976 return graphql.Null
9977 }
9978 res := resTmp.(bool)
9979 fc.Result = res
9980 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9981}
9982
9983func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9984 defer func() {
9985 if r := recover(); r != nil {
9986 ec.Error(ctx, ec.Recover(ctx, r))
9987 ret = graphql.Null
9988 }
9989 }()
9990 fc := &graphql.FieldContext{
9991 Object: "__Field",
9992 Field: field,
9993 Args: nil,
9994 IsMethod: true,
9995 }
9996
9997 ctx = graphql.WithFieldContext(ctx, fc)
9998 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9999 ctx = rctx // use context from middleware stack in children
10000 return obj.DeprecationReason(), nil
10001 })
10002 if err != nil {
10003 ec.Error(ctx, err)
10004 return graphql.Null
10005 }
10006 if resTmp == nil {
10007 return graphql.Null
10008 }
10009 res := resTmp.(*string)
10010 fc.Result = res
10011 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10012}
10013
10014func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
10015 defer func() {
10016 if r := recover(); r != nil {
10017 ec.Error(ctx, ec.Recover(ctx, r))
10018 ret = graphql.Null
10019 }
10020 }()
10021 fc := &graphql.FieldContext{
10022 Object: "__InputValue",
10023 Field: field,
10024 Args: nil,
10025 IsMethod: false,
10026 }
10027
10028 ctx = graphql.WithFieldContext(ctx, fc)
10029 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10030 ctx = rctx // use context from middleware stack in children
10031 return obj.Name, nil
10032 })
10033 if err != nil {
10034 ec.Error(ctx, err)
10035 return graphql.Null
10036 }
10037 if resTmp == nil {
10038 if !graphql.HasFieldError(ctx, fc) {
10039 ec.Errorf(ctx, "must not be null")
10040 }
10041 return graphql.Null
10042 }
10043 res := resTmp.(string)
10044 fc.Result = res
10045 return ec.marshalNString2string(ctx, field.Selections, res)
10046}
10047
10048func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
10049 defer func() {
10050 if r := recover(); r != nil {
10051 ec.Error(ctx, ec.Recover(ctx, r))
10052 ret = graphql.Null
10053 }
10054 }()
10055 fc := &graphql.FieldContext{
10056 Object: "__InputValue",
10057 Field: field,
10058 Args: nil,
10059 IsMethod: false,
10060 }
10061
10062 ctx = graphql.WithFieldContext(ctx, fc)
10063 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10064 ctx = rctx // use context from middleware stack in children
10065 return obj.Description, nil
10066 })
10067 if err != nil {
10068 ec.Error(ctx, err)
10069 return graphql.Null
10070 }
10071 if resTmp == nil {
10072 return graphql.Null
10073 }
10074 res := resTmp.(string)
10075 fc.Result = res
10076 return ec.marshalOString2string(ctx, field.Selections, res)
10077}
10078
10079func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
10080 defer func() {
10081 if r := recover(); r != nil {
10082 ec.Error(ctx, ec.Recover(ctx, r))
10083 ret = graphql.Null
10084 }
10085 }()
10086 fc := &graphql.FieldContext{
10087 Object: "__InputValue",
10088 Field: field,
10089 Args: nil,
10090 IsMethod: false,
10091 }
10092
10093 ctx = graphql.WithFieldContext(ctx, fc)
10094 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10095 ctx = rctx // use context from middleware stack in children
10096 return obj.Type, nil
10097 })
10098 if err != nil {
10099 ec.Error(ctx, err)
10100 return graphql.Null
10101 }
10102 if resTmp == nil {
10103 if !graphql.HasFieldError(ctx, fc) {
10104 ec.Errorf(ctx, "must not be null")
10105 }
10106 return graphql.Null
10107 }
10108 res := resTmp.(*introspection.Type)
10109 fc.Result = res
10110 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10111}
10112
10113func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
10114 defer func() {
10115 if r := recover(); r != nil {
10116 ec.Error(ctx, ec.Recover(ctx, r))
10117 ret = graphql.Null
10118 }
10119 }()
10120 fc := &graphql.FieldContext{
10121 Object: "__InputValue",
10122 Field: field,
10123 Args: nil,
10124 IsMethod: false,
10125 }
10126
10127 ctx = graphql.WithFieldContext(ctx, fc)
10128 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10129 ctx = rctx // use context from middleware stack in children
10130 return obj.DefaultValue, nil
10131 })
10132 if err != nil {
10133 ec.Error(ctx, err)
10134 return graphql.Null
10135 }
10136 if resTmp == nil {
10137 return graphql.Null
10138 }
10139 res := resTmp.(*string)
10140 fc.Result = res
10141 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10142}
10143
10144func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10145 defer func() {
10146 if r := recover(); r != nil {
10147 ec.Error(ctx, ec.Recover(ctx, r))
10148 ret = graphql.Null
10149 }
10150 }()
10151 fc := &graphql.FieldContext{
10152 Object: "__Schema",
10153 Field: field,
10154 Args: nil,
10155 IsMethod: true,
10156 }
10157
10158 ctx = graphql.WithFieldContext(ctx, fc)
10159 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10160 ctx = rctx // use context from middleware stack in children
10161 return obj.Types(), nil
10162 })
10163 if err != nil {
10164 ec.Error(ctx, err)
10165 return graphql.Null
10166 }
10167 if resTmp == nil {
10168 if !graphql.HasFieldError(ctx, fc) {
10169 ec.Errorf(ctx, "must not be null")
10170 }
10171 return graphql.Null
10172 }
10173 res := resTmp.([]introspection.Type)
10174 fc.Result = res
10175 return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10176}
10177
10178func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10179 defer func() {
10180 if r := recover(); r != nil {
10181 ec.Error(ctx, ec.Recover(ctx, r))
10182 ret = graphql.Null
10183 }
10184 }()
10185 fc := &graphql.FieldContext{
10186 Object: "__Schema",
10187 Field: field,
10188 Args: nil,
10189 IsMethod: true,
10190 }
10191
10192 ctx = graphql.WithFieldContext(ctx, fc)
10193 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10194 ctx = rctx // use context from middleware stack in children
10195 return obj.QueryType(), nil
10196 })
10197 if err != nil {
10198 ec.Error(ctx, err)
10199 return graphql.Null
10200 }
10201 if resTmp == nil {
10202 if !graphql.HasFieldError(ctx, fc) {
10203 ec.Errorf(ctx, "must not be null")
10204 }
10205 return graphql.Null
10206 }
10207 res := resTmp.(*introspection.Type)
10208 fc.Result = res
10209 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10210}
10211
10212func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10213 defer func() {
10214 if r := recover(); r != nil {
10215 ec.Error(ctx, ec.Recover(ctx, r))
10216 ret = graphql.Null
10217 }
10218 }()
10219 fc := &graphql.FieldContext{
10220 Object: "__Schema",
10221 Field: field,
10222 Args: nil,
10223 IsMethod: true,
10224 }
10225
10226 ctx = graphql.WithFieldContext(ctx, fc)
10227 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10228 ctx = rctx // use context from middleware stack in children
10229 return obj.MutationType(), nil
10230 })
10231 if err != nil {
10232 ec.Error(ctx, err)
10233 return graphql.Null
10234 }
10235 if resTmp == nil {
10236 return graphql.Null
10237 }
10238 res := resTmp.(*introspection.Type)
10239 fc.Result = res
10240 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10241}
10242
10243func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10244 defer func() {
10245 if r := recover(); r != nil {
10246 ec.Error(ctx, ec.Recover(ctx, r))
10247 ret = graphql.Null
10248 }
10249 }()
10250 fc := &graphql.FieldContext{
10251 Object: "__Schema",
10252 Field: field,
10253 Args: nil,
10254 IsMethod: true,
10255 }
10256
10257 ctx = graphql.WithFieldContext(ctx, fc)
10258 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10259 ctx = rctx // use context from middleware stack in children
10260 return obj.SubscriptionType(), nil
10261 })
10262 if err != nil {
10263 ec.Error(ctx, err)
10264 return graphql.Null
10265 }
10266 if resTmp == nil {
10267 return graphql.Null
10268 }
10269 res := resTmp.(*introspection.Type)
10270 fc.Result = res
10271 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10272}
10273
10274func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10275 defer func() {
10276 if r := recover(); r != nil {
10277 ec.Error(ctx, ec.Recover(ctx, r))
10278 ret = graphql.Null
10279 }
10280 }()
10281 fc := &graphql.FieldContext{
10282 Object: "__Schema",
10283 Field: field,
10284 Args: nil,
10285 IsMethod: true,
10286 }
10287
10288 ctx = graphql.WithFieldContext(ctx, fc)
10289 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10290 ctx = rctx // use context from middleware stack in children
10291 return obj.Directives(), nil
10292 })
10293 if err != nil {
10294 ec.Error(ctx, err)
10295 return graphql.Null
10296 }
10297 if resTmp == nil {
10298 if !graphql.HasFieldError(ctx, fc) {
10299 ec.Errorf(ctx, "must not be null")
10300 }
10301 return graphql.Null
10302 }
10303 res := resTmp.([]introspection.Directive)
10304 fc.Result = res
10305 return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
10306}
10307
10308func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10309 defer func() {
10310 if r := recover(); r != nil {
10311 ec.Error(ctx, ec.Recover(ctx, r))
10312 ret = graphql.Null
10313 }
10314 }()
10315 fc := &graphql.FieldContext{
10316 Object: "__Type",
10317 Field: field,
10318 Args: nil,
10319 IsMethod: true,
10320 }
10321
10322 ctx = graphql.WithFieldContext(ctx, fc)
10323 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10324 ctx = rctx // use context from middleware stack in children
10325 return obj.Kind(), nil
10326 })
10327 if err != nil {
10328 ec.Error(ctx, err)
10329 return graphql.Null
10330 }
10331 if resTmp == nil {
10332 if !graphql.HasFieldError(ctx, fc) {
10333 ec.Errorf(ctx, "must not be null")
10334 }
10335 return graphql.Null
10336 }
10337 res := resTmp.(string)
10338 fc.Result = res
10339 return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
10340}
10341
10342func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10343 defer func() {
10344 if r := recover(); r != nil {
10345 ec.Error(ctx, ec.Recover(ctx, r))
10346 ret = graphql.Null
10347 }
10348 }()
10349 fc := &graphql.FieldContext{
10350 Object: "__Type",
10351 Field: field,
10352 Args: nil,
10353 IsMethod: true,
10354 }
10355
10356 ctx = graphql.WithFieldContext(ctx, fc)
10357 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10358 ctx = rctx // use context from middleware stack in children
10359 return obj.Name(), nil
10360 })
10361 if err != nil {
10362 ec.Error(ctx, err)
10363 return graphql.Null
10364 }
10365 if resTmp == nil {
10366 return graphql.Null
10367 }
10368 res := resTmp.(*string)
10369 fc.Result = res
10370 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10371}
10372
10373func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10374 defer func() {
10375 if r := recover(); r != nil {
10376 ec.Error(ctx, ec.Recover(ctx, r))
10377 ret = graphql.Null
10378 }
10379 }()
10380 fc := &graphql.FieldContext{
10381 Object: "__Type",
10382 Field: field,
10383 Args: nil,
10384 IsMethod: true,
10385 }
10386
10387 ctx = graphql.WithFieldContext(ctx, fc)
10388 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10389 ctx = rctx // use context from middleware stack in children
10390 return obj.Description(), nil
10391 })
10392 if err != nil {
10393 ec.Error(ctx, err)
10394 return graphql.Null
10395 }
10396 if resTmp == nil {
10397 return graphql.Null
10398 }
10399 res := resTmp.(string)
10400 fc.Result = res
10401 return ec.marshalOString2string(ctx, field.Selections, res)
10402}
10403
10404func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10405 defer func() {
10406 if r := recover(); r != nil {
10407 ec.Error(ctx, ec.Recover(ctx, r))
10408 ret = graphql.Null
10409 }
10410 }()
10411 fc := &graphql.FieldContext{
10412 Object: "__Type",
10413 Field: field,
10414 Args: nil,
10415 IsMethod: true,
10416 }
10417
10418 ctx = graphql.WithFieldContext(ctx, fc)
10419 rawArgs := field.ArgumentMap(ec.Variables)
10420 args, err := ec.field___Type_fields_args(ctx, rawArgs)
10421 if err != nil {
10422 ec.Error(ctx, err)
10423 return graphql.Null
10424 }
10425 fc.Args = args
10426 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10427 ctx = rctx // use context from middleware stack in children
10428 return obj.Fields(args["includeDeprecated"].(bool)), nil
10429 })
10430 if err != nil {
10431 ec.Error(ctx, err)
10432 return graphql.Null
10433 }
10434 if resTmp == nil {
10435 return graphql.Null
10436 }
10437 res := resTmp.([]introspection.Field)
10438 fc.Result = res
10439 return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
10440}
10441
10442func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10443 defer func() {
10444 if r := recover(); r != nil {
10445 ec.Error(ctx, ec.Recover(ctx, r))
10446 ret = graphql.Null
10447 }
10448 }()
10449 fc := &graphql.FieldContext{
10450 Object: "__Type",
10451 Field: field,
10452 Args: nil,
10453 IsMethod: true,
10454 }
10455
10456 ctx = graphql.WithFieldContext(ctx, fc)
10457 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10458 ctx = rctx // use context from middleware stack in children
10459 return obj.Interfaces(), nil
10460 })
10461 if err != nil {
10462 ec.Error(ctx, err)
10463 return graphql.Null
10464 }
10465 if resTmp == nil {
10466 return graphql.Null
10467 }
10468 res := resTmp.([]introspection.Type)
10469 fc.Result = res
10470 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10471}
10472
10473func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10474 defer func() {
10475 if r := recover(); r != nil {
10476 ec.Error(ctx, ec.Recover(ctx, r))
10477 ret = graphql.Null
10478 }
10479 }()
10480 fc := &graphql.FieldContext{
10481 Object: "__Type",
10482 Field: field,
10483 Args: nil,
10484 IsMethod: true,
10485 }
10486
10487 ctx = graphql.WithFieldContext(ctx, fc)
10488 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10489 ctx = rctx // use context from middleware stack in children
10490 return obj.PossibleTypes(), nil
10491 })
10492 if err != nil {
10493 ec.Error(ctx, err)
10494 return graphql.Null
10495 }
10496 if resTmp == nil {
10497 return graphql.Null
10498 }
10499 res := resTmp.([]introspection.Type)
10500 fc.Result = res
10501 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10502}
10503
10504func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10505 defer func() {
10506 if r := recover(); r != nil {
10507 ec.Error(ctx, ec.Recover(ctx, r))
10508 ret = graphql.Null
10509 }
10510 }()
10511 fc := &graphql.FieldContext{
10512 Object: "__Type",
10513 Field: field,
10514 Args: nil,
10515 IsMethod: true,
10516 }
10517
10518 ctx = graphql.WithFieldContext(ctx, fc)
10519 rawArgs := field.ArgumentMap(ec.Variables)
10520 args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
10521 if err != nil {
10522 ec.Error(ctx, err)
10523 return graphql.Null
10524 }
10525 fc.Args = args
10526 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10527 ctx = rctx // use context from middleware stack in children
10528 return obj.EnumValues(args["includeDeprecated"].(bool)), nil
10529 })
10530 if err != nil {
10531 ec.Error(ctx, err)
10532 return graphql.Null
10533 }
10534 if resTmp == nil {
10535 return graphql.Null
10536 }
10537 res := resTmp.([]introspection.EnumValue)
10538 fc.Result = res
10539 return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
10540}
10541
10542func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10543 defer func() {
10544 if r := recover(); r != nil {
10545 ec.Error(ctx, ec.Recover(ctx, r))
10546 ret = graphql.Null
10547 }
10548 }()
10549 fc := &graphql.FieldContext{
10550 Object: "__Type",
10551 Field: field,
10552 Args: nil,
10553 IsMethod: true,
10554 }
10555
10556 ctx = graphql.WithFieldContext(ctx, fc)
10557 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10558 ctx = rctx // use context from middleware stack in children
10559 return obj.InputFields(), nil
10560 })
10561 if err != nil {
10562 ec.Error(ctx, err)
10563 return graphql.Null
10564 }
10565 if resTmp == nil {
10566 return graphql.Null
10567 }
10568 res := resTmp.([]introspection.InputValue)
10569 fc.Result = res
10570 return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
10571}
10572
10573func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10574 defer func() {
10575 if r := recover(); r != nil {
10576 ec.Error(ctx, ec.Recover(ctx, r))
10577 ret = graphql.Null
10578 }
10579 }()
10580 fc := &graphql.FieldContext{
10581 Object: "__Type",
10582 Field: field,
10583 Args: nil,
10584 IsMethod: true,
10585 }
10586
10587 ctx = graphql.WithFieldContext(ctx, fc)
10588 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10589 ctx = rctx // use context from middleware stack in children
10590 return obj.OfType(), nil
10591 })
10592 if err != nil {
10593 ec.Error(ctx, err)
10594 return graphql.Null
10595 }
10596 if resTmp == nil {
10597 return graphql.Null
10598 }
10599 res := resTmp.(*introspection.Type)
10600 fc.Result = res
10601 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10602}
10603
10604// endregion **************************** field.gotpl *****************************
10605
10606// region **************************** input.gotpl *****************************
10607
10608func (ec *executionContext) unmarshalInputAddCommentAndCloseBugInput(ctx context.Context, obj interface{}) (models.AddCommentAndCloseBugInput, error) {
10609 var it models.AddCommentAndCloseBugInput
10610 var asMap = obj.(map[string]interface{})
10611
10612 for k, v := range asMap {
10613 switch k {
10614 case "clientMutationId":
10615 var err error
10616 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10617 if err != nil {
10618 return it, err
10619 }
10620 case "repoRef":
10621 var err error
10622 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10623 if err != nil {
10624 return it, err
10625 }
10626 case "prefix":
10627 var err error
10628 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10629 if err != nil {
10630 return it, err
10631 }
10632 case "message":
10633 var err error
10634 it.Message, err = ec.unmarshalNString2string(ctx, v)
10635 if err != nil {
10636 return it, err
10637 }
10638 case "files":
10639 var err error
10640 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
10641 if err != nil {
10642 return it, err
10643 }
10644 }
10645 }
10646
10647 return it, nil
10648}
10649
10650func (ec *executionContext) unmarshalInputAddCommentAndReopenBugInput(ctx context.Context, obj interface{}) (models.AddCommentAndReopenBugInput, error) {
10651 var it models.AddCommentAndReopenBugInput
10652 var asMap = obj.(map[string]interface{})
10653
10654 for k, v := range asMap {
10655 switch k {
10656 case "clientMutationId":
10657 var err error
10658 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10659 if err != nil {
10660 return it, err
10661 }
10662 case "repoRef":
10663 var err error
10664 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10665 if err != nil {
10666 return it, err
10667 }
10668 case "prefix":
10669 var err error
10670 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10671 if err != nil {
10672 return it, err
10673 }
10674 case "message":
10675 var err error
10676 it.Message, err = ec.unmarshalNString2string(ctx, v)
10677 if err != nil {
10678 return it, err
10679 }
10680 case "files":
10681 var err error
10682 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
10683 if err != nil {
10684 return it, err
10685 }
10686 }
10687 }
10688
10689 return it, nil
10690}
10691
10692func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
10693 var it models.AddCommentInput
10694 var asMap = obj.(map[string]interface{})
10695
10696 for k, v := range asMap {
10697 switch k {
10698 case "clientMutationId":
10699 var err error
10700 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10701 if err != nil {
10702 return it, err
10703 }
10704 case "repoRef":
10705 var err error
10706 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10707 if err != nil {
10708 return it, err
10709 }
10710 case "prefix":
10711 var err error
10712 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10713 if err != nil {
10714 return it, err
10715 }
10716 case "message":
10717 var err error
10718 it.Message, err = ec.unmarshalNString2string(ctx, v)
10719 if err != nil {
10720 return it, err
10721 }
10722 case "files":
10723 var err error
10724 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
10725 if err != nil {
10726 return it, err
10727 }
10728 }
10729 }
10730
10731 return it, nil
10732}
10733
10734func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
10735 var it models.ChangeLabelInput
10736 var asMap = obj.(map[string]interface{})
10737
10738 for k, v := range asMap {
10739 switch k {
10740 case "clientMutationId":
10741 var err error
10742 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10743 if err != nil {
10744 return it, err
10745 }
10746 case "repoRef":
10747 var err error
10748 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10749 if err != nil {
10750 return it, err
10751 }
10752 case "prefix":
10753 var err error
10754 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10755 if err != nil {
10756 return it, err
10757 }
10758 case "added":
10759 var err error
10760 it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10761 if err != nil {
10762 return it, err
10763 }
10764 case "Removed":
10765 var err error
10766 it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10767 if err != nil {
10768 return it, err
10769 }
10770 }
10771 }
10772
10773 return it, nil
10774}
10775
10776func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
10777 var it models.CloseBugInput
10778 var asMap = obj.(map[string]interface{})
10779
10780 for k, v := range asMap {
10781 switch k {
10782 case "clientMutationId":
10783 var err error
10784 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10785 if err != nil {
10786 return it, err
10787 }
10788 case "repoRef":
10789 var err error
10790 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10791 if err != nil {
10792 return it, err
10793 }
10794 case "prefix":
10795 var err error
10796 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10797 if err != nil {
10798 return it, err
10799 }
10800 }
10801 }
10802
10803 return it, nil
10804}
10805
10806func (ec *executionContext) unmarshalInputEditCommentInput(ctx context.Context, obj interface{}) (models.EditCommentInput, error) {
10807 var it models.EditCommentInput
10808 var asMap = obj.(map[string]interface{})
10809
10810 for k, v := range asMap {
10811 switch k {
10812 case "clientMutationId":
10813 var err error
10814 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10815 if err != nil {
10816 return it, err
10817 }
10818 case "repoRef":
10819 var err error
10820 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10821 if err != nil {
10822 return it, err
10823 }
10824 case "prefix":
10825 var err error
10826 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10827 if err != nil {
10828 return it, err
10829 }
10830 case "target":
10831 var err error
10832 it.Target, err = ec.unmarshalNString2string(ctx, v)
10833 if err != nil {
10834 return it, err
10835 }
10836 case "message":
10837 var err error
10838 it.Message, err = ec.unmarshalNString2string(ctx, v)
10839 if err != nil {
10840 return it, err
10841 }
10842 case "files":
10843 var err error
10844 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
10845 if err != nil {
10846 return it, err
10847 }
10848 }
10849 }
10850
10851 return it, nil
10852}
10853
10854func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
10855 var it models.NewBugInput
10856 var asMap = obj.(map[string]interface{})
10857
10858 for k, v := range asMap {
10859 switch k {
10860 case "clientMutationId":
10861 var err error
10862 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10863 if err != nil {
10864 return it, err
10865 }
10866 case "repoRef":
10867 var err error
10868 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10869 if err != nil {
10870 return it, err
10871 }
10872 case "title":
10873 var err error
10874 it.Title, err = ec.unmarshalNString2string(ctx, v)
10875 if err != nil {
10876 return it, err
10877 }
10878 case "message":
10879 var err error
10880 it.Message, err = ec.unmarshalNString2string(ctx, v)
10881 if err != nil {
10882 return it, err
10883 }
10884 case "files":
10885 var err error
10886 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
10887 if err != nil {
10888 return it, err
10889 }
10890 }
10891 }
10892
10893 return it, nil
10894}
10895
10896func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
10897 var it models.OpenBugInput
10898 var asMap = obj.(map[string]interface{})
10899
10900 for k, v := range asMap {
10901 switch k {
10902 case "clientMutationId":
10903 var err error
10904 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10905 if err != nil {
10906 return it, err
10907 }
10908 case "repoRef":
10909 var err error
10910 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10911 if err != nil {
10912 return it, err
10913 }
10914 case "prefix":
10915 var err error
10916 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10917 if err != nil {
10918 return it, err
10919 }
10920 }
10921 }
10922
10923 return it, nil
10924}
10925
10926func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
10927 var it models.SetTitleInput
10928 var asMap = obj.(map[string]interface{})
10929
10930 for k, v := range asMap {
10931 switch k {
10932 case "clientMutationId":
10933 var err error
10934 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10935 if err != nil {
10936 return it, err
10937 }
10938 case "repoRef":
10939 var err error
10940 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10941 if err != nil {
10942 return it, err
10943 }
10944 case "prefix":
10945 var err error
10946 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10947 if err != nil {
10948 return it, err
10949 }
10950 case "title":
10951 var err error
10952 it.Title, err = ec.unmarshalNString2string(ctx, v)
10953 if err != nil {
10954 return it, err
10955 }
10956 }
10957 }
10958
10959 return it, nil
10960}
10961
10962// endregion **************************** input.gotpl *****************************
10963
10964// region ************************** interface.gotpl ***************************
10965
10966func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj models.Authored) graphql.Marshaler {
10967 switch obj := (obj).(type) {
10968 case nil:
10969 return graphql.Null
10970 case bug.Comment:
10971 return ec._Comment(ctx, sel, &obj)
10972 case *bug.Comment:
10973 if obj == nil {
10974 return graphql.Null
10975 }
10976 return ec._Comment(ctx, sel, obj)
10977 case models.BugWrapper:
10978 if obj == nil {
10979 return graphql.Null
10980 }
10981 return ec._Bug(ctx, sel, obj)
10982 case *bug.CreateOperation:
10983 if obj == nil {
10984 return graphql.Null
10985 }
10986 return ec._CreateOperation(ctx, sel, obj)
10987 case *bug.SetTitleOperation:
10988 if obj == nil {
10989 return graphql.Null
10990 }
10991 return ec._SetTitleOperation(ctx, sel, obj)
10992 case *bug.AddCommentOperation:
10993 if obj == nil {
10994 return graphql.Null
10995 }
10996 return ec._AddCommentOperation(ctx, sel, obj)
10997 case *bug.EditCommentOperation:
10998 if obj == nil {
10999 return graphql.Null
11000 }
11001 return ec._EditCommentOperation(ctx, sel, obj)
11002 case *bug.SetStatusOperation:
11003 if obj == nil {
11004 return graphql.Null
11005 }
11006 return ec._SetStatusOperation(ctx, sel, obj)
11007 case *bug.LabelChangeOperation:
11008 if obj == nil {
11009 return graphql.Null
11010 }
11011 return ec._LabelChangeOperation(ctx, sel, obj)
11012 case *bug.CreateTimelineItem:
11013 if obj == nil {
11014 return graphql.Null
11015 }
11016 return ec._CreateTimelineItem(ctx, sel, obj)
11017 case *bug.AddCommentTimelineItem:
11018 if obj == nil {
11019 return graphql.Null
11020 }
11021 return ec._AddCommentTimelineItem(ctx, sel, obj)
11022 case *bug.LabelChangeTimelineItem:
11023 if obj == nil {
11024 return graphql.Null
11025 }
11026 return ec._LabelChangeTimelineItem(ctx, sel, obj)
11027 case *bug.SetStatusTimelineItem:
11028 if obj == nil {
11029 return graphql.Null
11030 }
11031 return ec._SetStatusTimelineItem(ctx, sel, obj)
11032 case *bug.SetTitleTimelineItem:
11033 if obj == nil {
11034 return graphql.Null
11035 }
11036 return ec._SetTitleTimelineItem(ctx, sel, obj)
11037 default:
11038 panic(fmt.Errorf("unexpected type %T", obj))
11039 }
11040}
11041
11042func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj bug.Operation) graphql.Marshaler {
11043 switch obj := (obj).(type) {
11044 case nil:
11045 return graphql.Null
11046 case *bug.CreateOperation:
11047 if obj == nil {
11048 return graphql.Null
11049 }
11050 return ec._CreateOperation(ctx, sel, obj)
11051 case *bug.SetTitleOperation:
11052 if obj == nil {
11053 return graphql.Null
11054 }
11055 return ec._SetTitleOperation(ctx, sel, obj)
11056 case *bug.AddCommentOperation:
11057 if obj == nil {
11058 return graphql.Null
11059 }
11060 return ec._AddCommentOperation(ctx, sel, obj)
11061 case *bug.EditCommentOperation:
11062 if obj == nil {
11063 return graphql.Null
11064 }
11065 return ec._EditCommentOperation(ctx, sel, obj)
11066 case *bug.SetStatusOperation:
11067 if obj == nil {
11068 return graphql.Null
11069 }
11070 return ec._SetStatusOperation(ctx, sel, obj)
11071 case *bug.LabelChangeOperation:
11072 if obj == nil {
11073 return graphql.Null
11074 }
11075 return ec._LabelChangeOperation(ctx, sel, obj)
11076 default:
11077 panic(fmt.Errorf("unexpected type %T", obj))
11078 }
11079}
11080
11081func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
11082 switch obj := (obj).(type) {
11083 case nil:
11084 return graphql.Null
11085 case *bug.CreateTimelineItem:
11086 if obj == nil {
11087 return graphql.Null
11088 }
11089 return ec._CreateTimelineItem(ctx, sel, obj)
11090 case *bug.AddCommentTimelineItem:
11091 if obj == nil {
11092 return graphql.Null
11093 }
11094 return ec._AddCommentTimelineItem(ctx, sel, obj)
11095 case bug.LabelChangeTimelineItem:
11096 return ec._LabelChangeTimelineItem(ctx, sel, &obj)
11097 case *bug.LabelChangeTimelineItem:
11098 if obj == nil {
11099 return graphql.Null
11100 }
11101 return ec._LabelChangeTimelineItem(ctx, sel, obj)
11102 case bug.SetStatusTimelineItem:
11103 return ec._SetStatusTimelineItem(ctx, sel, &obj)
11104 case *bug.SetStatusTimelineItem:
11105 if obj == nil {
11106 return graphql.Null
11107 }
11108 return ec._SetStatusTimelineItem(ctx, sel, obj)
11109 case bug.SetTitleTimelineItem:
11110 return ec._SetTitleTimelineItem(ctx, sel, &obj)
11111 case *bug.SetTitleTimelineItem:
11112 if obj == nil {
11113 return graphql.Null
11114 }
11115 return ec._SetTitleTimelineItem(ctx, sel, obj)
11116 default:
11117 panic(fmt.Errorf("unexpected type %T", obj))
11118 }
11119}
11120
11121// endregion ************************** interface.gotpl ***************************
11122
11123// region **************************** object.gotpl ****************************
11124
11125var addCommentAndCloseBugPayloadImplementors = []string{"AddCommentAndCloseBugPayload"}
11126
11127func (ec *executionContext) _AddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentAndCloseBugPayload) graphql.Marshaler {
11128 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentAndCloseBugPayloadImplementors)
11129
11130 out := graphql.NewFieldSet(fields)
11131 var invalids uint32
11132 for i, field := range fields {
11133 switch field.Name {
11134 case "__typename":
11135 out.Values[i] = graphql.MarshalString("AddCommentAndCloseBugPayload")
11136 case "clientMutationId":
11137 out.Values[i] = ec._AddCommentAndCloseBugPayload_clientMutationId(ctx, field, obj)
11138 case "bug":
11139 out.Values[i] = ec._AddCommentAndCloseBugPayload_bug(ctx, field, obj)
11140 if out.Values[i] == graphql.Null {
11141 invalids++
11142 }
11143 case "commentOperation":
11144 out.Values[i] = ec._AddCommentAndCloseBugPayload_commentOperation(ctx, field, obj)
11145 if out.Values[i] == graphql.Null {
11146 invalids++
11147 }
11148 case "statusOperation":
11149 out.Values[i] = ec._AddCommentAndCloseBugPayload_statusOperation(ctx, field, obj)
11150 if out.Values[i] == graphql.Null {
11151 invalids++
11152 }
11153 default:
11154 panic("unknown field " + strconv.Quote(field.Name))
11155 }
11156 }
11157 out.Dispatch()
11158 if invalids > 0 {
11159 return graphql.Null
11160 }
11161 return out
11162}
11163
11164var addCommentAndReopenBugPayloadImplementors = []string{"AddCommentAndReopenBugPayload"}
11165
11166func (ec *executionContext) _AddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentAndReopenBugPayload) graphql.Marshaler {
11167 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentAndReopenBugPayloadImplementors)
11168
11169 out := graphql.NewFieldSet(fields)
11170 var invalids uint32
11171 for i, field := range fields {
11172 switch field.Name {
11173 case "__typename":
11174 out.Values[i] = graphql.MarshalString("AddCommentAndReopenBugPayload")
11175 case "clientMutationId":
11176 out.Values[i] = ec._AddCommentAndReopenBugPayload_clientMutationId(ctx, field, obj)
11177 case "bug":
11178 out.Values[i] = ec._AddCommentAndReopenBugPayload_bug(ctx, field, obj)
11179 if out.Values[i] == graphql.Null {
11180 invalids++
11181 }
11182 case "commentOperation":
11183 out.Values[i] = ec._AddCommentAndReopenBugPayload_commentOperation(ctx, field, obj)
11184 if out.Values[i] == graphql.Null {
11185 invalids++
11186 }
11187 case "statusOperation":
11188 out.Values[i] = ec._AddCommentAndReopenBugPayload_statusOperation(ctx, field, obj)
11189 if out.Values[i] == graphql.Null {
11190 invalids++
11191 }
11192 default:
11193 panic("unknown field " + strconv.Quote(field.Name))
11194 }
11195 }
11196 out.Dispatch()
11197 if invalids > 0 {
11198 return graphql.Null
11199 }
11200 return out
11201}
11202
11203var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
11204
11205func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
11206 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
11207
11208 out := graphql.NewFieldSet(fields)
11209 var invalids uint32
11210 for i, field := range fields {
11211 switch field.Name {
11212 case "__typename":
11213 out.Values[i] = graphql.MarshalString("AddCommentOperation")
11214 case "id":
11215 field := field
11216 out.Concurrently(i, func() (res graphql.Marshaler) {
11217 defer func() {
11218 if r := recover(); r != nil {
11219 ec.Error(ctx, ec.Recover(ctx, r))
11220 }
11221 }()
11222 res = ec._AddCommentOperation_id(ctx, field, obj)
11223 if res == graphql.Null {
11224 atomic.AddUint32(&invalids, 1)
11225 }
11226 return res
11227 })
11228 case "author":
11229 field := field
11230 out.Concurrently(i, func() (res graphql.Marshaler) {
11231 defer func() {
11232 if r := recover(); r != nil {
11233 ec.Error(ctx, ec.Recover(ctx, r))
11234 }
11235 }()
11236 res = ec._AddCommentOperation_author(ctx, field, obj)
11237 if res == graphql.Null {
11238 atomic.AddUint32(&invalids, 1)
11239 }
11240 return res
11241 })
11242 case "date":
11243 field := field
11244 out.Concurrently(i, func() (res graphql.Marshaler) {
11245 defer func() {
11246 if r := recover(); r != nil {
11247 ec.Error(ctx, ec.Recover(ctx, r))
11248 }
11249 }()
11250 res = ec._AddCommentOperation_date(ctx, field, obj)
11251 if res == graphql.Null {
11252 atomic.AddUint32(&invalids, 1)
11253 }
11254 return res
11255 })
11256 case "message":
11257 out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
11258 if out.Values[i] == graphql.Null {
11259 atomic.AddUint32(&invalids, 1)
11260 }
11261 case "files":
11262 out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
11263 if out.Values[i] == graphql.Null {
11264 atomic.AddUint32(&invalids, 1)
11265 }
11266 default:
11267 panic("unknown field " + strconv.Quote(field.Name))
11268 }
11269 }
11270 out.Dispatch()
11271 if invalids > 0 {
11272 return graphql.Null
11273 }
11274 return out
11275}
11276
11277var addCommentPayloadImplementors = []string{"AddCommentPayload"}
11278
11279func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
11280 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
11281
11282 out := graphql.NewFieldSet(fields)
11283 var invalids uint32
11284 for i, field := range fields {
11285 switch field.Name {
11286 case "__typename":
11287 out.Values[i] = graphql.MarshalString("AddCommentPayload")
11288 case "clientMutationId":
11289 out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
11290 case "bug":
11291 out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
11292 if out.Values[i] == graphql.Null {
11293 invalids++
11294 }
11295 case "operation":
11296 out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
11297 if out.Values[i] == graphql.Null {
11298 invalids++
11299 }
11300 default:
11301 panic("unknown field " + strconv.Quote(field.Name))
11302 }
11303 }
11304 out.Dispatch()
11305 if invalids > 0 {
11306 return graphql.Null
11307 }
11308 return out
11309}
11310
11311var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
11312
11313func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
11314 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
11315
11316 out := graphql.NewFieldSet(fields)
11317 var invalids uint32
11318 for i, field := range fields {
11319 switch field.Name {
11320 case "__typename":
11321 out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
11322 case "id":
11323 field := field
11324 out.Concurrently(i, func() (res graphql.Marshaler) {
11325 defer func() {
11326 if r := recover(); r != nil {
11327 ec.Error(ctx, ec.Recover(ctx, r))
11328 }
11329 }()
11330 res = ec._AddCommentTimelineItem_id(ctx, field, obj)
11331 if res == graphql.Null {
11332 atomic.AddUint32(&invalids, 1)
11333 }
11334 return res
11335 })
11336 case "author":
11337 field := field
11338 out.Concurrently(i, func() (res graphql.Marshaler) {
11339 defer func() {
11340 if r := recover(); r != nil {
11341 ec.Error(ctx, ec.Recover(ctx, r))
11342 }
11343 }()
11344 res = ec._AddCommentTimelineItem_author(ctx, field, obj)
11345 if res == graphql.Null {
11346 atomic.AddUint32(&invalids, 1)
11347 }
11348 return res
11349 })
11350 case "message":
11351 out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
11352 if out.Values[i] == graphql.Null {
11353 atomic.AddUint32(&invalids, 1)
11354 }
11355 case "messageIsEmpty":
11356 out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
11357 if out.Values[i] == graphql.Null {
11358 atomic.AddUint32(&invalids, 1)
11359 }
11360 case "files":
11361 out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
11362 if out.Values[i] == graphql.Null {
11363 atomic.AddUint32(&invalids, 1)
11364 }
11365 case "createdAt":
11366 field := field
11367 out.Concurrently(i, func() (res graphql.Marshaler) {
11368 defer func() {
11369 if r := recover(); r != nil {
11370 ec.Error(ctx, ec.Recover(ctx, r))
11371 }
11372 }()
11373 res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
11374 if res == graphql.Null {
11375 atomic.AddUint32(&invalids, 1)
11376 }
11377 return res
11378 })
11379 case "lastEdit":
11380 field := field
11381 out.Concurrently(i, func() (res graphql.Marshaler) {
11382 defer func() {
11383 if r := recover(); r != nil {
11384 ec.Error(ctx, ec.Recover(ctx, r))
11385 }
11386 }()
11387 res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
11388 if res == graphql.Null {
11389 atomic.AddUint32(&invalids, 1)
11390 }
11391 return res
11392 })
11393 case "edited":
11394 out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
11395 if out.Values[i] == graphql.Null {
11396 atomic.AddUint32(&invalids, 1)
11397 }
11398 case "history":
11399 out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
11400 if out.Values[i] == graphql.Null {
11401 atomic.AddUint32(&invalids, 1)
11402 }
11403 default:
11404 panic("unknown field " + strconv.Quote(field.Name))
11405 }
11406 }
11407 out.Dispatch()
11408 if invalids > 0 {
11409 return graphql.Null
11410 }
11411 return out
11412}
11413
11414var bugImplementors = []string{"Bug", "Authored"}
11415
11416func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
11417 fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
11418
11419 out := graphql.NewFieldSet(fields)
11420 var invalids uint32
11421 for i, field := range fields {
11422 switch field.Name {
11423 case "__typename":
11424 out.Values[i] = graphql.MarshalString("Bug")
11425 case "id":
11426 field := field
11427 out.Concurrently(i, func() (res graphql.Marshaler) {
11428 defer func() {
11429 if r := recover(); r != nil {
11430 ec.Error(ctx, ec.Recover(ctx, r))
11431 }
11432 }()
11433 res = ec._Bug_id(ctx, field, obj)
11434 if res == graphql.Null {
11435 atomic.AddUint32(&invalids, 1)
11436 }
11437 return res
11438 })
11439 case "humanId":
11440 field := field
11441 out.Concurrently(i, func() (res graphql.Marshaler) {
11442 defer func() {
11443 if r := recover(); r != nil {
11444 ec.Error(ctx, ec.Recover(ctx, r))
11445 }
11446 }()
11447 res = ec._Bug_humanId(ctx, field, obj)
11448 if res == graphql.Null {
11449 atomic.AddUint32(&invalids, 1)
11450 }
11451 return res
11452 })
11453 case "status":
11454 field := field
11455 out.Concurrently(i, func() (res graphql.Marshaler) {
11456 defer func() {
11457 if r := recover(); r != nil {
11458 ec.Error(ctx, ec.Recover(ctx, r))
11459 }
11460 }()
11461 res = ec._Bug_status(ctx, field, obj)
11462 if res == graphql.Null {
11463 atomic.AddUint32(&invalids, 1)
11464 }
11465 return res
11466 })
11467 case "title":
11468 out.Values[i] = ec._Bug_title(ctx, field, obj)
11469 if out.Values[i] == graphql.Null {
11470 atomic.AddUint32(&invalids, 1)
11471 }
11472 case "labels":
11473 out.Values[i] = ec._Bug_labels(ctx, field, obj)
11474 if out.Values[i] == graphql.Null {
11475 atomic.AddUint32(&invalids, 1)
11476 }
11477 case "author":
11478 out.Values[i] = ec._Bug_author(ctx, field, obj)
11479 if out.Values[i] == graphql.Null {
11480 atomic.AddUint32(&invalids, 1)
11481 }
11482 case "createdAt":
11483 out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
11484 if out.Values[i] == graphql.Null {
11485 atomic.AddUint32(&invalids, 1)
11486 }
11487 case "lastEdit":
11488 out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
11489 if out.Values[i] == graphql.Null {
11490 atomic.AddUint32(&invalids, 1)
11491 }
11492 case "actors":
11493 field := field
11494 out.Concurrently(i, func() (res graphql.Marshaler) {
11495 defer func() {
11496 if r := recover(); r != nil {
11497 ec.Error(ctx, ec.Recover(ctx, r))
11498 }
11499 }()
11500 res = ec._Bug_actors(ctx, field, obj)
11501 if res == graphql.Null {
11502 atomic.AddUint32(&invalids, 1)
11503 }
11504 return res
11505 })
11506 case "participants":
11507 field := field
11508 out.Concurrently(i, func() (res graphql.Marshaler) {
11509 defer func() {
11510 if r := recover(); r != nil {
11511 ec.Error(ctx, ec.Recover(ctx, r))
11512 }
11513 }()
11514 res = ec._Bug_participants(ctx, field, obj)
11515 if res == graphql.Null {
11516 atomic.AddUint32(&invalids, 1)
11517 }
11518 return res
11519 })
11520 case "comments":
11521 field := field
11522 out.Concurrently(i, func() (res graphql.Marshaler) {
11523 defer func() {
11524 if r := recover(); r != nil {
11525 ec.Error(ctx, ec.Recover(ctx, r))
11526 }
11527 }()
11528 res = ec._Bug_comments(ctx, field, obj)
11529 if res == graphql.Null {
11530 atomic.AddUint32(&invalids, 1)
11531 }
11532 return res
11533 })
11534 case "timeline":
11535 field := field
11536 out.Concurrently(i, func() (res graphql.Marshaler) {
11537 defer func() {
11538 if r := recover(); r != nil {
11539 ec.Error(ctx, ec.Recover(ctx, r))
11540 }
11541 }()
11542 res = ec._Bug_timeline(ctx, field, obj)
11543 if res == graphql.Null {
11544 atomic.AddUint32(&invalids, 1)
11545 }
11546 return res
11547 })
11548 case "operations":
11549 field := field
11550 out.Concurrently(i, func() (res graphql.Marshaler) {
11551 defer func() {
11552 if r := recover(); r != nil {
11553 ec.Error(ctx, ec.Recover(ctx, r))
11554 }
11555 }()
11556 res = ec._Bug_operations(ctx, field, obj)
11557 if res == graphql.Null {
11558 atomic.AddUint32(&invalids, 1)
11559 }
11560 return res
11561 })
11562 default:
11563 panic("unknown field " + strconv.Quote(field.Name))
11564 }
11565 }
11566 out.Dispatch()
11567 if invalids > 0 {
11568 return graphql.Null
11569 }
11570 return out
11571}
11572
11573var bugConnectionImplementors = []string{"BugConnection"}
11574
11575func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
11576 fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
11577
11578 out := graphql.NewFieldSet(fields)
11579 var invalids uint32
11580 for i, field := range fields {
11581 switch field.Name {
11582 case "__typename":
11583 out.Values[i] = graphql.MarshalString("BugConnection")
11584 case "edges":
11585 out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
11586 if out.Values[i] == graphql.Null {
11587 invalids++
11588 }
11589 case "nodes":
11590 out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
11591 if out.Values[i] == graphql.Null {
11592 invalids++
11593 }
11594 case "pageInfo":
11595 out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
11596 if out.Values[i] == graphql.Null {
11597 invalids++
11598 }
11599 case "totalCount":
11600 out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
11601 if out.Values[i] == graphql.Null {
11602 invalids++
11603 }
11604 default:
11605 panic("unknown field " + strconv.Quote(field.Name))
11606 }
11607 }
11608 out.Dispatch()
11609 if invalids > 0 {
11610 return graphql.Null
11611 }
11612 return out
11613}
11614
11615var bugEdgeImplementors = []string{"BugEdge"}
11616
11617func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
11618 fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
11619
11620 out := graphql.NewFieldSet(fields)
11621 var invalids uint32
11622 for i, field := range fields {
11623 switch field.Name {
11624 case "__typename":
11625 out.Values[i] = graphql.MarshalString("BugEdge")
11626 case "cursor":
11627 out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
11628 if out.Values[i] == graphql.Null {
11629 invalids++
11630 }
11631 case "node":
11632 out.Values[i] = ec._BugEdge_node(ctx, field, obj)
11633 if out.Values[i] == graphql.Null {
11634 invalids++
11635 }
11636 default:
11637 panic("unknown field " + strconv.Quote(field.Name))
11638 }
11639 }
11640 out.Dispatch()
11641 if invalids > 0 {
11642 return graphql.Null
11643 }
11644 return out
11645}
11646
11647var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
11648
11649func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
11650 fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
11651
11652 out := graphql.NewFieldSet(fields)
11653 var invalids uint32
11654 for i, field := range fields {
11655 switch field.Name {
11656 case "__typename":
11657 out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
11658 case "clientMutationId":
11659 out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
11660 case "bug":
11661 out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
11662 if out.Values[i] == graphql.Null {
11663 invalids++
11664 }
11665 case "operation":
11666 out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
11667 if out.Values[i] == graphql.Null {
11668 invalids++
11669 }
11670 case "results":
11671 out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
11672 if out.Values[i] == graphql.Null {
11673 invalids++
11674 }
11675 default:
11676 panic("unknown field " + strconv.Quote(field.Name))
11677 }
11678 }
11679 out.Dispatch()
11680 if invalids > 0 {
11681 return graphql.Null
11682 }
11683 return out
11684}
11685
11686var closeBugPayloadImplementors = []string{"CloseBugPayload"}
11687
11688func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
11689 fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
11690
11691 out := graphql.NewFieldSet(fields)
11692 var invalids uint32
11693 for i, field := range fields {
11694 switch field.Name {
11695 case "__typename":
11696 out.Values[i] = graphql.MarshalString("CloseBugPayload")
11697 case "clientMutationId":
11698 out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
11699 case "bug":
11700 out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
11701 if out.Values[i] == graphql.Null {
11702 invalids++
11703 }
11704 case "operation":
11705 out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
11706 if out.Values[i] == graphql.Null {
11707 invalids++
11708 }
11709 default:
11710 panic("unknown field " + strconv.Quote(field.Name))
11711 }
11712 }
11713 out.Dispatch()
11714 if invalids > 0 {
11715 return graphql.Null
11716 }
11717 return out
11718}
11719
11720var colorImplementors = []string{"Color"}
11721
11722func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
11723 fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
11724
11725 out := graphql.NewFieldSet(fields)
11726 var invalids uint32
11727 for i, field := range fields {
11728 switch field.Name {
11729 case "__typename":
11730 out.Values[i] = graphql.MarshalString("Color")
11731 case "R":
11732 field := field
11733 out.Concurrently(i, func() (res graphql.Marshaler) {
11734 defer func() {
11735 if r := recover(); r != nil {
11736 ec.Error(ctx, ec.Recover(ctx, r))
11737 }
11738 }()
11739 res = ec._Color_R(ctx, field, obj)
11740 if res == graphql.Null {
11741 atomic.AddUint32(&invalids, 1)
11742 }
11743 return res
11744 })
11745 case "G":
11746 field := field
11747 out.Concurrently(i, func() (res graphql.Marshaler) {
11748 defer func() {
11749 if r := recover(); r != nil {
11750 ec.Error(ctx, ec.Recover(ctx, r))
11751 }
11752 }()
11753 res = ec._Color_G(ctx, field, obj)
11754 if res == graphql.Null {
11755 atomic.AddUint32(&invalids, 1)
11756 }
11757 return res
11758 })
11759 case "B":
11760 field := field
11761 out.Concurrently(i, func() (res graphql.Marshaler) {
11762 defer func() {
11763 if r := recover(); r != nil {
11764 ec.Error(ctx, ec.Recover(ctx, r))
11765 }
11766 }()
11767 res = ec._Color_B(ctx, field, obj)
11768 if res == graphql.Null {
11769 atomic.AddUint32(&invalids, 1)
11770 }
11771 return res
11772 })
11773 default:
11774 panic("unknown field " + strconv.Quote(field.Name))
11775 }
11776 }
11777 out.Dispatch()
11778 if invalids > 0 {
11779 return graphql.Null
11780 }
11781 return out
11782}
11783
11784var commentImplementors = []string{"Comment", "Authored"}
11785
11786func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
11787 fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
11788
11789 out := graphql.NewFieldSet(fields)
11790 var invalids uint32
11791 for i, field := range fields {
11792 switch field.Name {
11793 case "__typename":
11794 out.Values[i] = graphql.MarshalString("Comment")
11795 case "author":
11796 field := field
11797 out.Concurrently(i, func() (res graphql.Marshaler) {
11798 defer func() {
11799 if r := recover(); r != nil {
11800 ec.Error(ctx, ec.Recover(ctx, r))
11801 }
11802 }()
11803 res = ec._Comment_author(ctx, field, obj)
11804 if res == graphql.Null {
11805 atomic.AddUint32(&invalids, 1)
11806 }
11807 return res
11808 })
11809 case "message":
11810 out.Values[i] = ec._Comment_message(ctx, field, obj)
11811 if out.Values[i] == graphql.Null {
11812 atomic.AddUint32(&invalids, 1)
11813 }
11814 case "files":
11815 out.Values[i] = ec._Comment_files(ctx, field, obj)
11816 if out.Values[i] == graphql.Null {
11817 atomic.AddUint32(&invalids, 1)
11818 }
11819 default:
11820 panic("unknown field " + strconv.Quote(field.Name))
11821 }
11822 }
11823 out.Dispatch()
11824 if invalids > 0 {
11825 return graphql.Null
11826 }
11827 return out
11828}
11829
11830var commentConnectionImplementors = []string{"CommentConnection"}
11831
11832func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
11833 fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
11834
11835 out := graphql.NewFieldSet(fields)
11836 var invalids uint32
11837 for i, field := range fields {
11838 switch field.Name {
11839 case "__typename":
11840 out.Values[i] = graphql.MarshalString("CommentConnection")
11841 case "edges":
11842 out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
11843 if out.Values[i] == graphql.Null {
11844 invalids++
11845 }
11846 case "nodes":
11847 out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
11848 if out.Values[i] == graphql.Null {
11849 invalids++
11850 }
11851 case "pageInfo":
11852 out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
11853 if out.Values[i] == graphql.Null {
11854 invalids++
11855 }
11856 case "totalCount":
11857 out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
11858 if out.Values[i] == graphql.Null {
11859 invalids++
11860 }
11861 default:
11862 panic("unknown field " + strconv.Quote(field.Name))
11863 }
11864 }
11865 out.Dispatch()
11866 if invalids > 0 {
11867 return graphql.Null
11868 }
11869 return out
11870}
11871
11872var commentEdgeImplementors = []string{"CommentEdge"}
11873
11874func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
11875 fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
11876
11877 out := graphql.NewFieldSet(fields)
11878 var invalids uint32
11879 for i, field := range fields {
11880 switch field.Name {
11881 case "__typename":
11882 out.Values[i] = graphql.MarshalString("CommentEdge")
11883 case "cursor":
11884 out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
11885 if out.Values[i] == graphql.Null {
11886 invalids++
11887 }
11888 case "node":
11889 out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
11890 if out.Values[i] == graphql.Null {
11891 invalids++
11892 }
11893 default:
11894 panic("unknown field " + strconv.Quote(field.Name))
11895 }
11896 }
11897 out.Dispatch()
11898 if invalids > 0 {
11899 return graphql.Null
11900 }
11901 return out
11902}
11903
11904var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
11905
11906func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
11907 fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
11908
11909 out := graphql.NewFieldSet(fields)
11910 var invalids uint32
11911 for i, field := range fields {
11912 switch field.Name {
11913 case "__typename":
11914 out.Values[i] = graphql.MarshalString("CommentHistoryStep")
11915 case "message":
11916 out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
11917 if out.Values[i] == graphql.Null {
11918 atomic.AddUint32(&invalids, 1)
11919 }
11920 case "date":
11921 field := field
11922 out.Concurrently(i, func() (res graphql.Marshaler) {
11923 defer func() {
11924 if r := recover(); r != nil {
11925 ec.Error(ctx, ec.Recover(ctx, r))
11926 }
11927 }()
11928 res = ec._CommentHistoryStep_date(ctx, field, obj)
11929 if res == graphql.Null {
11930 atomic.AddUint32(&invalids, 1)
11931 }
11932 return res
11933 })
11934 default:
11935 panic("unknown field " + strconv.Quote(field.Name))
11936 }
11937 }
11938 out.Dispatch()
11939 if invalids > 0 {
11940 return graphql.Null
11941 }
11942 return out
11943}
11944
11945var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
11946
11947func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
11948 fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
11949
11950 out := graphql.NewFieldSet(fields)
11951 var invalids uint32
11952 for i, field := range fields {
11953 switch field.Name {
11954 case "__typename":
11955 out.Values[i] = graphql.MarshalString("CreateOperation")
11956 case "id":
11957 field := field
11958 out.Concurrently(i, func() (res graphql.Marshaler) {
11959 defer func() {
11960 if r := recover(); r != nil {
11961 ec.Error(ctx, ec.Recover(ctx, r))
11962 }
11963 }()
11964 res = ec._CreateOperation_id(ctx, field, obj)
11965 if res == graphql.Null {
11966 atomic.AddUint32(&invalids, 1)
11967 }
11968 return res
11969 })
11970 case "author":
11971 field := field
11972 out.Concurrently(i, func() (res graphql.Marshaler) {
11973 defer func() {
11974 if r := recover(); r != nil {
11975 ec.Error(ctx, ec.Recover(ctx, r))
11976 }
11977 }()
11978 res = ec._CreateOperation_author(ctx, field, obj)
11979 if res == graphql.Null {
11980 atomic.AddUint32(&invalids, 1)
11981 }
11982 return res
11983 })
11984 case "date":
11985 field := field
11986 out.Concurrently(i, func() (res graphql.Marshaler) {
11987 defer func() {
11988 if r := recover(); r != nil {
11989 ec.Error(ctx, ec.Recover(ctx, r))
11990 }
11991 }()
11992 res = ec._CreateOperation_date(ctx, field, obj)
11993 if res == graphql.Null {
11994 atomic.AddUint32(&invalids, 1)
11995 }
11996 return res
11997 })
11998 case "title":
11999 out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
12000 if out.Values[i] == graphql.Null {
12001 atomic.AddUint32(&invalids, 1)
12002 }
12003 case "message":
12004 out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
12005 if out.Values[i] == graphql.Null {
12006 atomic.AddUint32(&invalids, 1)
12007 }
12008 case "files":
12009 out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
12010 if out.Values[i] == graphql.Null {
12011 atomic.AddUint32(&invalids, 1)
12012 }
12013 default:
12014 panic("unknown field " + strconv.Quote(field.Name))
12015 }
12016 }
12017 out.Dispatch()
12018 if invalids > 0 {
12019 return graphql.Null
12020 }
12021 return out
12022}
12023
12024var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
12025
12026func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
12027 fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
12028
12029 out := graphql.NewFieldSet(fields)
12030 var invalids uint32
12031 for i, field := range fields {
12032 switch field.Name {
12033 case "__typename":
12034 out.Values[i] = graphql.MarshalString("CreateTimelineItem")
12035 case "id":
12036 field := field
12037 out.Concurrently(i, func() (res graphql.Marshaler) {
12038 defer func() {
12039 if r := recover(); r != nil {
12040 ec.Error(ctx, ec.Recover(ctx, r))
12041 }
12042 }()
12043 res = ec._CreateTimelineItem_id(ctx, field, obj)
12044 if res == graphql.Null {
12045 atomic.AddUint32(&invalids, 1)
12046 }
12047 return res
12048 })
12049 case "author":
12050 field := field
12051 out.Concurrently(i, func() (res graphql.Marshaler) {
12052 defer func() {
12053 if r := recover(); r != nil {
12054 ec.Error(ctx, ec.Recover(ctx, r))
12055 }
12056 }()
12057 res = ec._CreateTimelineItem_author(ctx, field, obj)
12058 if res == graphql.Null {
12059 atomic.AddUint32(&invalids, 1)
12060 }
12061 return res
12062 })
12063 case "message":
12064 out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
12065 if out.Values[i] == graphql.Null {
12066 atomic.AddUint32(&invalids, 1)
12067 }
12068 case "messageIsEmpty":
12069 out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
12070 if out.Values[i] == graphql.Null {
12071 atomic.AddUint32(&invalids, 1)
12072 }
12073 case "files":
12074 out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
12075 if out.Values[i] == graphql.Null {
12076 atomic.AddUint32(&invalids, 1)
12077 }
12078 case "createdAt":
12079 field := field
12080 out.Concurrently(i, func() (res graphql.Marshaler) {
12081 defer func() {
12082 if r := recover(); r != nil {
12083 ec.Error(ctx, ec.Recover(ctx, r))
12084 }
12085 }()
12086 res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
12087 if res == graphql.Null {
12088 atomic.AddUint32(&invalids, 1)
12089 }
12090 return res
12091 })
12092 case "lastEdit":
12093 field := field
12094 out.Concurrently(i, func() (res graphql.Marshaler) {
12095 defer func() {
12096 if r := recover(); r != nil {
12097 ec.Error(ctx, ec.Recover(ctx, r))
12098 }
12099 }()
12100 res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
12101 if res == graphql.Null {
12102 atomic.AddUint32(&invalids, 1)
12103 }
12104 return res
12105 })
12106 case "edited":
12107 out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
12108 if out.Values[i] == graphql.Null {
12109 atomic.AddUint32(&invalids, 1)
12110 }
12111 case "history":
12112 out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
12113 if out.Values[i] == graphql.Null {
12114 atomic.AddUint32(&invalids, 1)
12115 }
12116 default:
12117 panic("unknown field " + strconv.Quote(field.Name))
12118 }
12119 }
12120 out.Dispatch()
12121 if invalids > 0 {
12122 return graphql.Null
12123 }
12124 return out
12125}
12126
12127var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
12128
12129func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
12130 fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
12131
12132 out := graphql.NewFieldSet(fields)
12133 var invalids uint32
12134 for i, field := range fields {
12135 switch field.Name {
12136 case "__typename":
12137 out.Values[i] = graphql.MarshalString("EditCommentOperation")
12138 case "id":
12139 field := field
12140 out.Concurrently(i, func() (res graphql.Marshaler) {
12141 defer func() {
12142 if r := recover(); r != nil {
12143 ec.Error(ctx, ec.Recover(ctx, r))
12144 }
12145 }()
12146 res = ec._EditCommentOperation_id(ctx, field, obj)
12147 if res == graphql.Null {
12148 atomic.AddUint32(&invalids, 1)
12149 }
12150 return res
12151 })
12152 case "author":
12153 field := field
12154 out.Concurrently(i, func() (res graphql.Marshaler) {
12155 defer func() {
12156 if r := recover(); r != nil {
12157 ec.Error(ctx, ec.Recover(ctx, r))
12158 }
12159 }()
12160 res = ec._EditCommentOperation_author(ctx, field, obj)
12161 if res == graphql.Null {
12162 atomic.AddUint32(&invalids, 1)
12163 }
12164 return res
12165 })
12166 case "date":
12167 field := field
12168 out.Concurrently(i, func() (res graphql.Marshaler) {
12169 defer func() {
12170 if r := recover(); r != nil {
12171 ec.Error(ctx, ec.Recover(ctx, r))
12172 }
12173 }()
12174 res = ec._EditCommentOperation_date(ctx, field, obj)
12175 if res == graphql.Null {
12176 atomic.AddUint32(&invalids, 1)
12177 }
12178 return res
12179 })
12180 case "target":
12181 field := field
12182 out.Concurrently(i, func() (res graphql.Marshaler) {
12183 defer func() {
12184 if r := recover(); r != nil {
12185 ec.Error(ctx, ec.Recover(ctx, r))
12186 }
12187 }()
12188 res = ec._EditCommentOperation_target(ctx, field, obj)
12189 if res == graphql.Null {
12190 atomic.AddUint32(&invalids, 1)
12191 }
12192 return res
12193 })
12194 case "message":
12195 out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
12196 if out.Values[i] == graphql.Null {
12197 atomic.AddUint32(&invalids, 1)
12198 }
12199 case "files":
12200 out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
12201 if out.Values[i] == graphql.Null {
12202 atomic.AddUint32(&invalids, 1)
12203 }
12204 default:
12205 panic("unknown field " + strconv.Quote(field.Name))
12206 }
12207 }
12208 out.Dispatch()
12209 if invalids > 0 {
12210 return graphql.Null
12211 }
12212 return out
12213}
12214
12215var editCommentPayloadImplementors = []string{"EditCommentPayload"}
12216
12217func (ec *executionContext) _EditCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.EditCommentPayload) graphql.Marshaler {
12218 fields := graphql.CollectFields(ec.OperationContext, sel, editCommentPayloadImplementors)
12219
12220 out := graphql.NewFieldSet(fields)
12221 var invalids uint32
12222 for i, field := range fields {
12223 switch field.Name {
12224 case "__typename":
12225 out.Values[i] = graphql.MarshalString("EditCommentPayload")
12226 case "clientMutationId":
12227 out.Values[i] = ec._EditCommentPayload_clientMutationId(ctx, field, obj)
12228 case "bug":
12229 out.Values[i] = ec._EditCommentPayload_bug(ctx, field, obj)
12230 if out.Values[i] == graphql.Null {
12231 invalids++
12232 }
12233 case "operation":
12234 out.Values[i] = ec._EditCommentPayload_operation(ctx, field, obj)
12235 if out.Values[i] == graphql.Null {
12236 invalids++
12237 }
12238 default:
12239 panic("unknown field " + strconv.Quote(field.Name))
12240 }
12241 }
12242 out.Dispatch()
12243 if invalids > 0 {
12244 return graphql.Null
12245 }
12246 return out
12247}
12248
12249var identityImplementors = []string{"Identity"}
12250
12251func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj models.IdentityWrapper) graphql.Marshaler {
12252 fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
12253
12254 out := graphql.NewFieldSet(fields)
12255 var invalids uint32
12256 for i, field := range fields {
12257 switch field.Name {
12258 case "__typename":
12259 out.Values[i] = graphql.MarshalString("Identity")
12260 case "id":
12261 field := field
12262 out.Concurrently(i, func() (res graphql.Marshaler) {
12263 defer func() {
12264 if r := recover(); r != nil {
12265 ec.Error(ctx, ec.Recover(ctx, r))
12266 }
12267 }()
12268 res = ec._Identity_id(ctx, field, obj)
12269 if res == graphql.Null {
12270 atomic.AddUint32(&invalids, 1)
12271 }
12272 return res
12273 })
12274 case "humanId":
12275 field := field
12276 out.Concurrently(i, func() (res graphql.Marshaler) {
12277 defer func() {
12278 if r := recover(); r != nil {
12279 ec.Error(ctx, ec.Recover(ctx, r))
12280 }
12281 }()
12282 res = ec._Identity_humanId(ctx, field, obj)
12283 if res == graphql.Null {
12284 atomic.AddUint32(&invalids, 1)
12285 }
12286 return res
12287 })
12288 case "name":
12289 out.Values[i] = ec._Identity_name(ctx, field, obj)
12290 case "email":
12291 out.Values[i] = ec._Identity_email(ctx, field, obj)
12292 case "login":
12293 out.Values[i] = ec._Identity_login(ctx, field, obj)
12294 case "displayName":
12295 out.Values[i] = ec._Identity_displayName(ctx, field, obj)
12296 if out.Values[i] == graphql.Null {
12297 atomic.AddUint32(&invalids, 1)
12298 }
12299 case "avatarUrl":
12300 out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
12301 case "isProtected":
12302 out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
12303 if out.Values[i] == graphql.Null {
12304 atomic.AddUint32(&invalids, 1)
12305 }
12306 default:
12307 panic("unknown field " + strconv.Quote(field.Name))
12308 }
12309 }
12310 out.Dispatch()
12311 if invalids > 0 {
12312 return graphql.Null
12313 }
12314 return out
12315}
12316
12317var identityConnectionImplementors = []string{"IdentityConnection"}
12318
12319func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
12320 fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
12321
12322 out := graphql.NewFieldSet(fields)
12323 var invalids uint32
12324 for i, field := range fields {
12325 switch field.Name {
12326 case "__typename":
12327 out.Values[i] = graphql.MarshalString("IdentityConnection")
12328 case "edges":
12329 out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
12330 if out.Values[i] == graphql.Null {
12331 invalids++
12332 }
12333 case "nodes":
12334 out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
12335 if out.Values[i] == graphql.Null {
12336 invalids++
12337 }
12338 case "pageInfo":
12339 out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
12340 if out.Values[i] == graphql.Null {
12341 invalids++
12342 }
12343 case "totalCount":
12344 out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
12345 if out.Values[i] == graphql.Null {
12346 invalids++
12347 }
12348 default:
12349 panic("unknown field " + strconv.Quote(field.Name))
12350 }
12351 }
12352 out.Dispatch()
12353 if invalids > 0 {
12354 return graphql.Null
12355 }
12356 return out
12357}
12358
12359var identityEdgeImplementors = []string{"IdentityEdge"}
12360
12361func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
12362 fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
12363
12364 out := graphql.NewFieldSet(fields)
12365 var invalids uint32
12366 for i, field := range fields {
12367 switch field.Name {
12368 case "__typename":
12369 out.Values[i] = graphql.MarshalString("IdentityEdge")
12370 case "cursor":
12371 out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
12372 if out.Values[i] == graphql.Null {
12373 invalids++
12374 }
12375 case "node":
12376 out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
12377 if out.Values[i] == graphql.Null {
12378 invalids++
12379 }
12380 default:
12381 panic("unknown field " + strconv.Quote(field.Name))
12382 }
12383 }
12384 out.Dispatch()
12385 if invalids > 0 {
12386 return graphql.Null
12387 }
12388 return out
12389}
12390
12391var labelImplementors = []string{"Label"}
12392
12393func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
12394 fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
12395
12396 out := graphql.NewFieldSet(fields)
12397 var invalids uint32
12398 for i, field := range fields {
12399 switch field.Name {
12400 case "__typename":
12401 out.Values[i] = graphql.MarshalString("Label")
12402 case "name":
12403 field := field
12404 out.Concurrently(i, func() (res graphql.Marshaler) {
12405 defer func() {
12406 if r := recover(); r != nil {
12407 ec.Error(ctx, ec.Recover(ctx, r))
12408 }
12409 }()
12410 res = ec._Label_name(ctx, field, obj)
12411 if res == graphql.Null {
12412 atomic.AddUint32(&invalids, 1)
12413 }
12414 return res
12415 })
12416 case "color":
12417 field := field
12418 out.Concurrently(i, func() (res graphql.Marshaler) {
12419 defer func() {
12420 if r := recover(); r != nil {
12421 ec.Error(ctx, ec.Recover(ctx, r))
12422 }
12423 }()
12424 res = ec._Label_color(ctx, field, obj)
12425 if res == graphql.Null {
12426 atomic.AddUint32(&invalids, 1)
12427 }
12428 return res
12429 })
12430 default:
12431 panic("unknown field " + strconv.Quote(field.Name))
12432 }
12433 }
12434 out.Dispatch()
12435 if invalids > 0 {
12436 return graphql.Null
12437 }
12438 return out
12439}
12440
12441var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
12442
12443func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
12444 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
12445
12446 out := graphql.NewFieldSet(fields)
12447 var invalids uint32
12448 for i, field := range fields {
12449 switch field.Name {
12450 case "__typename":
12451 out.Values[i] = graphql.MarshalString("LabelChangeOperation")
12452 case "id":
12453 field := field
12454 out.Concurrently(i, func() (res graphql.Marshaler) {
12455 defer func() {
12456 if r := recover(); r != nil {
12457 ec.Error(ctx, ec.Recover(ctx, r))
12458 }
12459 }()
12460 res = ec._LabelChangeOperation_id(ctx, field, obj)
12461 if res == graphql.Null {
12462 atomic.AddUint32(&invalids, 1)
12463 }
12464 return res
12465 })
12466 case "author":
12467 field := field
12468 out.Concurrently(i, func() (res graphql.Marshaler) {
12469 defer func() {
12470 if r := recover(); r != nil {
12471 ec.Error(ctx, ec.Recover(ctx, r))
12472 }
12473 }()
12474 res = ec._LabelChangeOperation_author(ctx, field, obj)
12475 if res == graphql.Null {
12476 atomic.AddUint32(&invalids, 1)
12477 }
12478 return res
12479 })
12480 case "date":
12481 field := field
12482 out.Concurrently(i, func() (res graphql.Marshaler) {
12483 defer func() {
12484 if r := recover(); r != nil {
12485 ec.Error(ctx, ec.Recover(ctx, r))
12486 }
12487 }()
12488 res = ec._LabelChangeOperation_date(ctx, field, obj)
12489 if res == graphql.Null {
12490 atomic.AddUint32(&invalids, 1)
12491 }
12492 return res
12493 })
12494 case "added":
12495 out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
12496 if out.Values[i] == graphql.Null {
12497 atomic.AddUint32(&invalids, 1)
12498 }
12499 case "removed":
12500 out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
12501 if out.Values[i] == graphql.Null {
12502 atomic.AddUint32(&invalids, 1)
12503 }
12504 default:
12505 panic("unknown field " + strconv.Quote(field.Name))
12506 }
12507 }
12508 out.Dispatch()
12509 if invalids > 0 {
12510 return graphql.Null
12511 }
12512 return out
12513}
12514
12515var labelChangeResultImplementors = []string{"LabelChangeResult"}
12516
12517func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
12518 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
12519
12520 out := graphql.NewFieldSet(fields)
12521 var invalids uint32
12522 for i, field := range fields {
12523 switch field.Name {
12524 case "__typename":
12525 out.Values[i] = graphql.MarshalString("LabelChangeResult")
12526 case "label":
12527 out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
12528 if out.Values[i] == graphql.Null {
12529 atomic.AddUint32(&invalids, 1)
12530 }
12531 case "status":
12532 field := field
12533 out.Concurrently(i, func() (res graphql.Marshaler) {
12534 defer func() {
12535 if r := recover(); r != nil {
12536 ec.Error(ctx, ec.Recover(ctx, r))
12537 }
12538 }()
12539 res = ec._LabelChangeResult_status(ctx, field, obj)
12540 if res == graphql.Null {
12541 atomic.AddUint32(&invalids, 1)
12542 }
12543 return res
12544 })
12545 default:
12546 panic("unknown field " + strconv.Quote(field.Name))
12547 }
12548 }
12549 out.Dispatch()
12550 if invalids > 0 {
12551 return graphql.Null
12552 }
12553 return out
12554}
12555
12556var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
12557
12558func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
12559 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
12560
12561 out := graphql.NewFieldSet(fields)
12562 var invalids uint32
12563 for i, field := range fields {
12564 switch field.Name {
12565 case "__typename":
12566 out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
12567 case "id":
12568 field := field
12569 out.Concurrently(i, func() (res graphql.Marshaler) {
12570 defer func() {
12571 if r := recover(); r != nil {
12572 ec.Error(ctx, ec.Recover(ctx, r))
12573 }
12574 }()
12575 res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
12576 if res == graphql.Null {
12577 atomic.AddUint32(&invalids, 1)
12578 }
12579 return res
12580 })
12581 case "author":
12582 field := field
12583 out.Concurrently(i, func() (res graphql.Marshaler) {
12584 defer func() {
12585 if r := recover(); r != nil {
12586 ec.Error(ctx, ec.Recover(ctx, r))
12587 }
12588 }()
12589 res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
12590 if res == graphql.Null {
12591 atomic.AddUint32(&invalids, 1)
12592 }
12593 return res
12594 })
12595 case "date":
12596 field := field
12597 out.Concurrently(i, func() (res graphql.Marshaler) {
12598 defer func() {
12599 if r := recover(); r != nil {
12600 ec.Error(ctx, ec.Recover(ctx, r))
12601 }
12602 }()
12603 res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
12604 if res == graphql.Null {
12605 atomic.AddUint32(&invalids, 1)
12606 }
12607 return res
12608 })
12609 case "added":
12610 out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
12611 if out.Values[i] == graphql.Null {
12612 atomic.AddUint32(&invalids, 1)
12613 }
12614 case "removed":
12615 out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
12616 if out.Values[i] == graphql.Null {
12617 atomic.AddUint32(&invalids, 1)
12618 }
12619 default:
12620 panic("unknown field " + strconv.Quote(field.Name))
12621 }
12622 }
12623 out.Dispatch()
12624 if invalids > 0 {
12625 return graphql.Null
12626 }
12627 return out
12628}
12629
12630var labelConnectionImplementors = []string{"LabelConnection"}
12631
12632func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
12633 fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
12634
12635 out := graphql.NewFieldSet(fields)
12636 var invalids uint32
12637 for i, field := range fields {
12638 switch field.Name {
12639 case "__typename":
12640 out.Values[i] = graphql.MarshalString("LabelConnection")
12641 case "edges":
12642 out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
12643 if out.Values[i] == graphql.Null {
12644 invalids++
12645 }
12646 case "nodes":
12647 out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
12648 if out.Values[i] == graphql.Null {
12649 invalids++
12650 }
12651 case "pageInfo":
12652 out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
12653 if out.Values[i] == graphql.Null {
12654 invalids++
12655 }
12656 case "totalCount":
12657 out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
12658 if out.Values[i] == graphql.Null {
12659 invalids++
12660 }
12661 default:
12662 panic("unknown field " + strconv.Quote(field.Name))
12663 }
12664 }
12665 out.Dispatch()
12666 if invalids > 0 {
12667 return graphql.Null
12668 }
12669 return out
12670}
12671
12672var labelEdgeImplementors = []string{"LabelEdge"}
12673
12674func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
12675 fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
12676
12677 out := graphql.NewFieldSet(fields)
12678 var invalids uint32
12679 for i, field := range fields {
12680 switch field.Name {
12681 case "__typename":
12682 out.Values[i] = graphql.MarshalString("LabelEdge")
12683 case "cursor":
12684 out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
12685 if out.Values[i] == graphql.Null {
12686 invalids++
12687 }
12688 case "node":
12689 out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
12690 if out.Values[i] == graphql.Null {
12691 invalids++
12692 }
12693 default:
12694 panic("unknown field " + strconv.Quote(field.Name))
12695 }
12696 }
12697 out.Dispatch()
12698 if invalids > 0 {
12699 return graphql.Null
12700 }
12701 return out
12702}
12703
12704var mutationImplementors = []string{"Mutation"}
12705
12706func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12707 fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
12708
12709 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12710 Object: "Mutation",
12711 })
12712
12713 out := graphql.NewFieldSet(fields)
12714 var invalids uint32
12715 for i, field := range fields {
12716 switch field.Name {
12717 case "__typename":
12718 out.Values[i] = graphql.MarshalString("Mutation")
12719 case "newBug":
12720 out.Values[i] = ec._Mutation_newBug(ctx, field)
12721 if out.Values[i] == graphql.Null {
12722 invalids++
12723 }
12724 case "addComment":
12725 out.Values[i] = ec._Mutation_addComment(ctx, field)
12726 if out.Values[i] == graphql.Null {
12727 invalids++
12728 }
12729 case "addCommentAndClose":
12730 out.Values[i] = ec._Mutation_addCommentAndClose(ctx, field)
12731 if out.Values[i] == graphql.Null {
12732 invalids++
12733 }
12734 case "addCommentAndReopen":
12735 out.Values[i] = ec._Mutation_addCommentAndReopen(ctx, field)
12736 if out.Values[i] == graphql.Null {
12737 invalids++
12738 }
12739 case "editComment":
12740 out.Values[i] = ec._Mutation_editComment(ctx, field)
12741 if out.Values[i] == graphql.Null {
12742 invalids++
12743 }
12744 case "changeLabels":
12745 out.Values[i] = ec._Mutation_changeLabels(ctx, field)
12746 if out.Values[i] == graphql.Null {
12747 invalids++
12748 }
12749 case "openBug":
12750 out.Values[i] = ec._Mutation_openBug(ctx, field)
12751 if out.Values[i] == graphql.Null {
12752 invalids++
12753 }
12754 case "closeBug":
12755 out.Values[i] = ec._Mutation_closeBug(ctx, field)
12756 if out.Values[i] == graphql.Null {
12757 invalids++
12758 }
12759 case "setTitle":
12760 out.Values[i] = ec._Mutation_setTitle(ctx, field)
12761 if out.Values[i] == graphql.Null {
12762 invalids++
12763 }
12764 default:
12765 panic("unknown field " + strconv.Quote(field.Name))
12766 }
12767 }
12768 out.Dispatch()
12769 if invalids > 0 {
12770 return graphql.Null
12771 }
12772 return out
12773}
12774
12775var newBugPayloadImplementors = []string{"NewBugPayload"}
12776
12777func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
12778 fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
12779
12780 out := graphql.NewFieldSet(fields)
12781 var invalids uint32
12782 for i, field := range fields {
12783 switch field.Name {
12784 case "__typename":
12785 out.Values[i] = graphql.MarshalString("NewBugPayload")
12786 case "clientMutationId":
12787 out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
12788 case "bug":
12789 out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
12790 if out.Values[i] == graphql.Null {
12791 invalids++
12792 }
12793 case "operation":
12794 out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
12795 if out.Values[i] == graphql.Null {
12796 invalids++
12797 }
12798 default:
12799 panic("unknown field " + strconv.Quote(field.Name))
12800 }
12801 }
12802 out.Dispatch()
12803 if invalids > 0 {
12804 return graphql.Null
12805 }
12806 return out
12807}
12808
12809var openBugPayloadImplementors = []string{"OpenBugPayload"}
12810
12811func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
12812 fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
12813
12814 out := graphql.NewFieldSet(fields)
12815 var invalids uint32
12816 for i, field := range fields {
12817 switch field.Name {
12818 case "__typename":
12819 out.Values[i] = graphql.MarshalString("OpenBugPayload")
12820 case "clientMutationId":
12821 out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
12822 case "bug":
12823 out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
12824 if out.Values[i] == graphql.Null {
12825 invalids++
12826 }
12827 case "operation":
12828 out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
12829 if out.Values[i] == graphql.Null {
12830 invalids++
12831 }
12832 default:
12833 panic("unknown field " + strconv.Quote(field.Name))
12834 }
12835 }
12836 out.Dispatch()
12837 if invalids > 0 {
12838 return graphql.Null
12839 }
12840 return out
12841}
12842
12843var operationConnectionImplementors = []string{"OperationConnection"}
12844
12845func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
12846 fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
12847
12848 out := graphql.NewFieldSet(fields)
12849 var invalids uint32
12850 for i, field := range fields {
12851 switch field.Name {
12852 case "__typename":
12853 out.Values[i] = graphql.MarshalString("OperationConnection")
12854 case "edges":
12855 out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
12856 if out.Values[i] == graphql.Null {
12857 invalids++
12858 }
12859 case "nodes":
12860 out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
12861 if out.Values[i] == graphql.Null {
12862 invalids++
12863 }
12864 case "pageInfo":
12865 out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
12866 if out.Values[i] == graphql.Null {
12867 invalids++
12868 }
12869 case "totalCount":
12870 out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
12871 if out.Values[i] == graphql.Null {
12872 invalids++
12873 }
12874 default:
12875 panic("unknown field " + strconv.Quote(field.Name))
12876 }
12877 }
12878 out.Dispatch()
12879 if invalids > 0 {
12880 return graphql.Null
12881 }
12882 return out
12883}
12884
12885var operationEdgeImplementors = []string{"OperationEdge"}
12886
12887func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
12888 fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
12889
12890 out := graphql.NewFieldSet(fields)
12891 var invalids uint32
12892 for i, field := range fields {
12893 switch field.Name {
12894 case "__typename":
12895 out.Values[i] = graphql.MarshalString("OperationEdge")
12896 case "cursor":
12897 out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
12898 if out.Values[i] == graphql.Null {
12899 invalids++
12900 }
12901 case "node":
12902 out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
12903 if out.Values[i] == graphql.Null {
12904 invalids++
12905 }
12906 default:
12907 panic("unknown field " + strconv.Quote(field.Name))
12908 }
12909 }
12910 out.Dispatch()
12911 if invalids > 0 {
12912 return graphql.Null
12913 }
12914 return out
12915}
12916
12917var pageInfoImplementors = []string{"PageInfo"}
12918
12919func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
12920 fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
12921
12922 out := graphql.NewFieldSet(fields)
12923 var invalids uint32
12924 for i, field := range fields {
12925 switch field.Name {
12926 case "__typename":
12927 out.Values[i] = graphql.MarshalString("PageInfo")
12928 case "hasNextPage":
12929 out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
12930 if out.Values[i] == graphql.Null {
12931 invalids++
12932 }
12933 case "hasPreviousPage":
12934 out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
12935 if out.Values[i] == graphql.Null {
12936 invalids++
12937 }
12938 case "startCursor":
12939 out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
12940 if out.Values[i] == graphql.Null {
12941 invalids++
12942 }
12943 case "endCursor":
12944 out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
12945 if out.Values[i] == graphql.Null {
12946 invalids++
12947 }
12948 default:
12949 panic("unknown field " + strconv.Quote(field.Name))
12950 }
12951 }
12952 out.Dispatch()
12953 if invalids > 0 {
12954 return graphql.Null
12955 }
12956 return out
12957}
12958
12959var queryImplementors = []string{"Query"}
12960
12961func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12962 fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
12963
12964 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12965 Object: "Query",
12966 })
12967
12968 out := graphql.NewFieldSet(fields)
12969 var invalids uint32
12970 for i, field := range fields {
12971 switch field.Name {
12972 case "__typename":
12973 out.Values[i] = graphql.MarshalString("Query")
12974 case "repository":
12975 field := field
12976 out.Concurrently(i, func() (res graphql.Marshaler) {
12977 defer func() {
12978 if r := recover(); r != nil {
12979 ec.Error(ctx, ec.Recover(ctx, r))
12980 }
12981 }()
12982 res = ec._Query_repository(ctx, field)
12983 return res
12984 })
12985 case "__type":
12986 out.Values[i] = ec._Query___type(ctx, field)
12987 case "__schema":
12988 out.Values[i] = ec._Query___schema(ctx, field)
12989 default:
12990 panic("unknown field " + strconv.Quote(field.Name))
12991 }
12992 }
12993 out.Dispatch()
12994 if invalids > 0 {
12995 return graphql.Null
12996 }
12997 return out
12998}
12999
13000var repositoryImplementors = []string{"Repository"}
13001
13002func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
13003 fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
13004
13005 out := graphql.NewFieldSet(fields)
13006 var invalids uint32
13007 for i, field := range fields {
13008 switch field.Name {
13009 case "__typename":
13010 out.Values[i] = graphql.MarshalString("Repository")
13011 case "name":
13012 field := field
13013 out.Concurrently(i, func() (res graphql.Marshaler) {
13014 defer func() {
13015 if r := recover(); r != nil {
13016 ec.Error(ctx, ec.Recover(ctx, r))
13017 }
13018 }()
13019 res = ec._Repository_name(ctx, field, obj)
13020 return res
13021 })
13022 case "allBugs":
13023 field := field
13024 out.Concurrently(i, func() (res graphql.Marshaler) {
13025 defer func() {
13026 if r := recover(); r != nil {
13027 ec.Error(ctx, ec.Recover(ctx, r))
13028 }
13029 }()
13030 res = ec._Repository_allBugs(ctx, field, obj)
13031 if res == graphql.Null {
13032 atomic.AddUint32(&invalids, 1)
13033 }
13034 return res
13035 })
13036 case "bug":
13037 field := field
13038 out.Concurrently(i, func() (res graphql.Marshaler) {
13039 defer func() {
13040 if r := recover(); r != nil {
13041 ec.Error(ctx, ec.Recover(ctx, r))
13042 }
13043 }()
13044 res = ec._Repository_bug(ctx, field, obj)
13045 return res
13046 })
13047 case "allIdentities":
13048 field := field
13049 out.Concurrently(i, func() (res graphql.Marshaler) {
13050 defer func() {
13051 if r := recover(); r != nil {
13052 ec.Error(ctx, ec.Recover(ctx, r))
13053 }
13054 }()
13055 res = ec._Repository_allIdentities(ctx, field, obj)
13056 if res == graphql.Null {
13057 atomic.AddUint32(&invalids, 1)
13058 }
13059 return res
13060 })
13061 case "identity":
13062 field := field
13063 out.Concurrently(i, func() (res graphql.Marshaler) {
13064 defer func() {
13065 if r := recover(); r != nil {
13066 ec.Error(ctx, ec.Recover(ctx, r))
13067 }
13068 }()
13069 res = ec._Repository_identity(ctx, field, obj)
13070 return res
13071 })
13072 case "userIdentity":
13073 field := field
13074 out.Concurrently(i, func() (res graphql.Marshaler) {
13075 defer func() {
13076 if r := recover(); r != nil {
13077 ec.Error(ctx, ec.Recover(ctx, r))
13078 }
13079 }()
13080 res = ec._Repository_userIdentity(ctx, field, obj)
13081 return res
13082 })
13083 case "validLabels":
13084 field := field
13085 out.Concurrently(i, func() (res graphql.Marshaler) {
13086 defer func() {
13087 if r := recover(); r != nil {
13088 ec.Error(ctx, ec.Recover(ctx, r))
13089 }
13090 }()
13091 res = ec._Repository_validLabels(ctx, field, obj)
13092 if res == graphql.Null {
13093 atomic.AddUint32(&invalids, 1)
13094 }
13095 return res
13096 })
13097 default:
13098 panic("unknown field " + strconv.Quote(field.Name))
13099 }
13100 }
13101 out.Dispatch()
13102 if invalids > 0 {
13103 return graphql.Null
13104 }
13105 return out
13106}
13107
13108var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
13109
13110func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
13111 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
13112
13113 out := graphql.NewFieldSet(fields)
13114 var invalids uint32
13115 for i, field := range fields {
13116 switch field.Name {
13117 case "__typename":
13118 out.Values[i] = graphql.MarshalString("SetStatusOperation")
13119 case "id":
13120 field := field
13121 out.Concurrently(i, func() (res graphql.Marshaler) {
13122 defer func() {
13123 if r := recover(); r != nil {
13124 ec.Error(ctx, ec.Recover(ctx, r))
13125 }
13126 }()
13127 res = ec._SetStatusOperation_id(ctx, field, obj)
13128 if res == graphql.Null {
13129 atomic.AddUint32(&invalids, 1)
13130 }
13131 return res
13132 })
13133 case "author":
13134 field := field
13135 out.Concurrently(i, func() (res graphql.Marshaler) {
13136 defer func() {
13137 if r := recover(); r != nil {
13138 ec.Error(ctx, ec.Recover(ctx, r))
13139 }
13140 }()
13141 res = ec._SetStatusOperation_author(ctx, field, obj)
13142 if res == graphql.Null {
13143 atomic.AddUint32(&invalids, 1)
13144 }
13145 return res
13146 })
13147 case "date":
13148 field := field
13149 out.Concurrently(i, func() (res graphql.Marshaler) {
13150 defer func() {
13151 if r := recover(); r != nil {
13152 ec.Error(ctx, ec.Recover(ctx, r))
13153 }
13154 }()
13155 res = ec._SetStatusOperation_date(ctx, field, obj)
13156 if res == graphql.Null {
13157 atomic.AddUint32(&invalids, 1)
13158 }
13159 return res
13160 })
13161 case "status":
13162 field := field
13163 out.Concurrently(i, func() (res graphql.Marshaler) {
13164 defer func() {
13165 if r := recover(); r != nil {
13166 ec.Error(ctx, ec.Recover(ctx, r))
13167 }
13168 }()
13169 res = ec._SetStatusOperation_status(ctx, field, obj)
13170 if res == graphql.Null {
13171 atomic.AddUint32(&invalids, 1)
13172 }
13173 return res
13174 })
13175 default:
13176 panic("unknown field " + strconv.Quote(field.Name))
13177 }
13178 }
13179 out.Dispatch()
13180 if invalids > 0 {
13181 return graphql.Null
13182 }
13183 return out
13184}
13185
13186var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
13187
13188func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
13189 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
13190
13191 out := graphql.NewFieldSet(fields)
13192 var invalids uint32
13193 for i, field := range fields {
13194 switch field.Name {
13195 case "__typename":
13196 out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
13197 case "id":
13198 field := field
13199 out.Concurrently(i, func() (res graphql.Marshaler) {
13200 defer func() {
13201 if r := recover(); r != nil {
13202 ec.Error(ctx, ec.Recover(ctx, r))
13203 }
13204 }()
13205 res = ec._SetStatusTimelineItem_id(ctx, field, obj)
13206 if res == graphql.Null {
13207 atomic.AddUint32(&invalids, 1)
13208 }
13209 return res
13210 })
13211 case "author":
13212 field := field
13213 out.Concurrently(i, func() (res graphql.Marshaler) {
13214 defer func() {
13215 if r := recover(); r != nil {
13216 ec.Error(ctx, ec.Recover(ctx, r))
13217 }
13218 }()
13219 res = ec._SetStatusTimelineItem_author(ctx, field, obj)
13220 if res == graphql.Null {
13221 atomic.AddUint32(&invalids, 1)
13222 }
13223 return res
13224 })
13225 case "date":
13226 field := field
13227 out.Concurrently(i, func() (res graphql.Marshaler) {
13228 defer func() {
13229 if r := recover(); r != nil {
13230 ec.Error(ctx, ec.Recover(ctx, r))
13231 }
13232 }()
13233 res = ec._SetStatusTimelineItem_date(ctx, field, obj)
13234 if res == graphql.Null {
13235 atomic.AddUint32(&invalids, 1)
13236 }
13237 return res
13238 })
13239 case "status":
13240 field := field
13241 out.Concurrently(i, func() (res graphql.Marshaler) {
13242 defer func() {
13243 if r := recover(); r != nil {
13244 ec.Error(ctx, ec.Recover(ctx, r))
13245 }
13246 }()
13247 res = ec._SetStatusTimelineItem_status(ctx, field, obj)
13248 if res == graphql.Null {
13249 atomic.AddUint32(&invalids, 1)
13250 }
13251 return res
13252 })
13253 default:
13254 panic("unknown field " + strconv.Quote(field.Name))
13255 }
13256 }
13257 out.Dispatch()
13258 if invalids > 0 {
13259 return graphql.Null
13260 }
13261 return out
13262}
13263
13264var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
13265
13266func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
13267 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
13268
13269 out := graphql.NewFieldSet(fields)
13270 var invalids uint32
13271 for i, field := range fields {
13272 switch field.Name {
13273 case "__typename":
13274 out.Values[i] = graphql.MarshalString("SetTitleOperation")
13275 case "id":
13276 field := field
13277 out.Concurrently(i, func() (res graphql.Marshaler) {
13278 defer func() {
13279 if r := recover(); r != nil {
13280 ec.Error(ctx, ec.Recover(ctx, r))
13281 }
13282 }()
13283 res = ec._SetTitleOperation_id(ctx, field, obj)
13284 if res == graphql.Null {
13285 atomic.AddUint32(&invalids, 1)
13286 }
13287 return res
13288 })
13289 case "author":
13290 field := field
13291 out.Concurrently(i, func() (res graphql.Marshaler) {
13292 defer func() {
13293 if r := recover(); r != nil {
13294 ec.Error(ctx, ec.Recover(ctx, r))
13295 }
13296 }()
13297 res = ec._SetTitleOperation_author(ctx, field, obj)
13298 if res == graphql.Null {
13299 atomic.AddUint32(&invalids, 1)
13300 }
13301 return res
13302 })
13303 case "date":
13304 field := field
13305 out.Concurrently(i, func() (res graphql.Marshaler) {
13306 defer func() {
13307 if r := recover(); r != nil {
13308 ec.Error(ctx, ec.Recover(ctx, r))
13309 }
13310 }()
13311 res = ec._SetTitleOperation_date(ctx, field, obj)
13312 if res == graphql.Null {
13313 atomic.AddUint32(&invalids, 1)
13314 }
13315 return res
13316 })
13317 case "title":
13318 out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
13319 if out.Values[i] == graphql.Null {
13320 atomic.AddUint32(&invalids, 1)
13321 }
13322 case "was":
13323 out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
13324 if out.Values[i] == graphql.Null {
13325 atomic.AddUint32(&invalids, 1)
13326 }
13327 default:
13328 panic("unknown field " + strconv.Quote(field.Name))
13329 }
13330 }
13331 out.Dispatch()
13332 if invalids > 0 {
13333 return graphql.Null
13334 }
13335 return out
13336}
13337
13338var setTitlePayloadImplementors = []string{"SetTitlePayload"}
13339
13340func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
13341 fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
13342
13343 out := graphql.NewFieldSet(fields)
13344 var invalids uint32
13345 for i, field := range fields {
13346 switch field.Name {
13347 case "__typename":
13348 out.Values[i] = graphql.MarshalString("SetTitlePayload")
13349 case "clientMutationId":
13350 out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
13351 case "bug":
13352 out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
13353 if out.Values[i] == graphql.Null {
13354 invalids++
13355 }
13356 case "operation":
13357 out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
13358 if out.Values[i] == graphql.Null {
13359 invalids++
13360 }
13361 default:
13362 panic("unknown field " + strconv.Quote(field.Name))
13363 }
13364 }
13365 out.Dispatch()
13366 if invalids > 0 {
13367 return graphql.Null
13368 }
13369 return out
13370}
13371
13372var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
13373
13374func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
13375 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
13376
13377 out := graphql.NewFieldSet(fields)
13378 var invalids uint32
13379 for i, field := range fields {
13380 switch field.Name {
13381 case "__typename":
13382 out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
13383 case "id":
13384 field := field
13385 out.Concurrently(i, func() (res graphql.Marshaler) {
13386 defer func() {
13387 if r := recover(); r != nil {
13388 ec.Error(ctx, ec.Recover(ctx, r))
13389 }
13390 }()
13391 res = ec._SetTitleTimelineItem_id(ctx, field, obj)
13392 if res == graphql.Null {
13393 atomic.AddUint32(&invalids, 1)
13394 }
13395 return res
13396 })
13397 case "author":
13398 field := field
13399 out.Concurrently(i, func() (res graphql.Marshaler) {
13400 defer func() {
13401 if r := recover(); r != nil {
13402 ec.Error(ctx, ec.Recover(ctx, r))
13403 }
13404 }()
13405 res = ec._SetTitleTimelineItem_author(ctx, field, obj)
13406 if res == graphql.Null {
13407 atomic.AddUint32(&invalids, 1)
13408 }
13409 return res
13410 })
13411 case "date":
13412 field := field
13413 out.Concurrently(i, func() (res graphql.Marshaler) {
13414 defer func() {
13415 if r := recover(); r != nil {
13416 ec.Error(ctx, ec.Recover(ctx, r))
13417 }
13418 }()
13419 res = ec._SetTitleTimelineItem_date(ctx, field, obj)
13420 if res == graphql.Null {
13421 atomic.AddUint32(&invalids, 1)
13422 }
13423 return res
13424 })
13425 case "title":
13426 out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
13427 if out.Values[i] == graphql.Null {
13428 atomic.AddUint32(&invalids, 1)
13429 }
13430 case "was":
13431 out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
13432 if out.Values[i] == graphql.Null {
13433 atomic.AddUint32(&invalids, 1)
13434 }
13435 default:
13436 panic("unknown field " + strconv.Quote(field.Name))
13437 }
13438 }
13439 out.Dispatch()
13440 if invalids > 0 {
13441 return graphql.Null
13442 }
13443 return out
13444}
13445
13446var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
13447
13448func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
13449 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
13450
13451 out := graphql.NewFieldSet(fields)
13452 var invalids uint32
13453 for i, field := range fields {
13454 switch field.Name {
13455 case "__typename":
13456 out.Values[i] = graphql.MarshalString("TimelineItemConnection")
13457 case "edges":
13458 out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
13459 if out.Values[i] == graphql.Null {
13460 invalids++
13461 }
13462 case "nodes":
13463 out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
13464 if out.Values[i] == graphql.Null {
13465 invalids++
13466 }
13467 case "pageInfo":
13468 out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
13469 if out.Values[i] == graphql.Null {
13470 invalids++
13471 }
13472 case "totalCount":
13473 out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
13474 if out.Values[i] == graphql.Null {
13475 invalids++
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 timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
13489
13490func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
13491 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
13492
13493 out := graphql.NewFieldSet(fields)
13494 var invalids uint32
13495 for i, field := range fields {
13496 switch field.Name {
13497 case "__typename":
13498 out.Values[i] = graphql.MarshalString("TimelineItemEdge")
13499 case "cursor":
13500 out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
13501 if out.Values[i] == graphql.Null {
13502 invalids++
13503 }
13504 case "node":
13505 out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
13506 if out.Values[i] == graphql.Null {
13507 invalids++
13508 }
13509 default:
13510 panic("unknown field " + strconv.Quote(field.Name))
13511 }
13512 }
13513 out.Dispatch()
13514 if invalids > 0 {
13515 return graphql.Null
13516 }
13517 return out
13518}
13519
13520var __DirectiveImplementors = []string{"__Directive"}
13521
13522func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
13523 fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
13524
13525 out := graphql.NewFieldSet(fields)
13526 var invalids uint32
13527 for i, field := range fields {
13528 switch field.Name {
13529 case "__typename":
13530 out.Values[i] = graphql.MarshalString("__Directive")
13531 case "name":
13532 out.Values[i] = ec.___Directive_name(ctx, field, obj)
13533 if out.Values[i] == graphql.Null {
13534 invalids++
13535 }
13536 case "description":
13537 out.Values[i] = ec.___Directive_description(ctx, field, obj)
13538 case "locations":
13539 out.Values[i] = ec.___Directive_locations(ctx, field, obj)
13540 if out.Values[i] == graphql.Null {
13541 invalids++
13542 }
13543 case "args":
13544 out.Values[i] = ec.___Directive_args(ctx, field, obj)
13545 if out.Values[i] == graphql.Null {
13546 invalids++
13547 }
13548 default:
13549 panic("unknown field " + strconv.Quote(field.Name))
13550 }
13551 }
13552 out.Dispatch()
13553 if invalids > 0 {
13554 return graphql.Null
13555 }
13556 return out
13557}
13558
13559var __EnumValueImplementors = []string{"__EnumValue"}
13560
13561func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
13562 fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
13563
13564 out := graphql.NewFieldSet(fields)
13565 var invalids uint32
13566 for i, field := range fields {
13567 switch field.Name {
13568 case "__typename":
13569 out.Values[i] = graphql.MarshalString("__EnumValue")
13570 case "name":
13571 out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
13572 if out.Values[i] == graphql.Null {
13573 invalids++
13574 }
13575 case "description":
13576 out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
13577 case "isDeprecated":
13578 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
13579 if out.Values[i] == graphql.Null {
13580 invalids++
13581 }
13582 case "deprecationReason":
13583 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
13584 default:
13585 panic("unknown field " + strconv.Quote(field.Name))
13586 }
13587 }
13588 out.Dispatch()
13589 if invalids > 0 {
13590 return graphql.Null
13591 }
13592 return out
13593}
13594
13595var __FieldImplementors = []string{"__Field"}
13596
13597func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
13598 fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
13599
13600 out := graphql.NewFieldSet(fields)
13601 var invalids uint32
13602 for i, field := range fields {
13603 switch field.Name {
13604 case "__typename":
13605 out.Values[i] = graphql.MarshalString("__Field")
13606 case "name":
13607 out.Values[i] = ec.___Field_name(ctx, field, obj)
13608 if out.Values[i] == graphql.Null {
13609 invalids++
13610 }
13611 case "description":
13612 out.Values[i] = ec.___Field_description(ctx, field, obj)
13613 case "args":
13614 out.Values[i] = ec.___Field_args(ctx, field, obj)
13615 if out.Values[i] == graphql.Null {
13616 invalids++
13617 }
13618 case "type":
13619 out.Values[i] = ec.___Field_type(ctx, field, obj)
13620 if out.Values[i] == graphql.Null {
13621 invalids++
13622 }
13623 case "isDeprecated":
13624 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
13625 if out.Values[i] == graphql.Null {
13626 invalids++
13627 }
13628 case "deprecationReason":
13629 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
13630 default:
13631 panic("unknown field " + strconv.Quote(field.Name))
13632 }
13633 }
13634 out.Dispatch()
13635 if invalids > 0 {
13636 return graphql.Null
13637 }
13638 return out
13639}
13640
13641var __InputValueImplementors = []string{"__InputValue"}
13642
13643func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
13644 fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
13645
13646 out := graphql.NewFieldSet(fields)
13647 var invalids uint32
13648 for i, field := range fields {
13649 switch field.Name {
13650 case "__typename":
13651 out.Values[i] = graphql.MarshalString("__InputValue")
13652 case "name":
13653 out.Values[i] = ec.___InputValue_name(ctx, field, obj)
13654 if out.Values[i] == graphql.Null {
13655 invalids++
13656 }
13657 case "description":
13658 out.Values[i] = ec.___InputValue_description(ctx, field, obj)
13659 case "type":
13660 out.Values[i] = ec.___InputValue_type(ctx, field, obj)
13661 if out.Values[i] == graphql.Null {
13662 invalids++
13663 }
13664 case "defaultValue":
13665 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
13666 default:
13667 panic("unknown field " + strconv.Quote(field.Name))
13668 }
13669 }
13670 out.Dispatch()
13671 if invalids > 0 {
13672 return graphql.Null
13673 }
13674 return out
13675}
13676
13677var __SchemaImplementors = []string{"__Schema"}
13678
13679func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
13680 fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
13681
13682 out := graphql.NewFieldSet(fields)
13683 var invalids uint32
13684 for i, field := range fields {
13685 switch field.Name {
13686 case "__typename":
13687 out.Values[i] = graphql.MarshalString("__Schema")
13688 case "types":
13689 out.Values[i] = ec.___Schema_types(ctx, field, obj)
13690 if out.Values[i] == graphql.Null {
13691 invalids++
13692 }
13693 case "queryType":
13694 out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
13695 if out.Values[i] == graphql.Null {
13696 invalids++
13697 }
13698 case "mutationType":
13699 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
13700 case "subscriptionType":
13701 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
13702 case "directives":
13703 out.Values[i] = ec.___Schema_directives(ctx, field, obj)
13704 if out.Values[i] == graphql.Null {
13705 invalids++
13706 }
13707 default:
13708 panic("unknown field " + strconv.Quote(field.Name))
13709 }
13710 }
13711 out.Dispatch()
13712 if invalids > 0 {
13713 return graphql.Null
13714 }
13715 return out
13716}
13717
13718var __TypeImplementors = []string{"__Type"}
13719
13720func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
13721 fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
13722
13723 out := graphql.NewFieldSet(fields)
13724 var invalids uint32
13725 for i, field := range fields {
13726 switch field.Name {
13727 case "__typename":
13728 out.Values[i] = graphql.MarshalString("__Type")
13729 case "kind":
13730 out.Values[i] = ec.___Type_kind(ctx, field, obj)
13731 if out.Values[i] == graphql.Null {
13732 invalids++
13733 }
13734 case "name":
13735 out.Values[i] = ec.___Type_name(ctx, field, obj)
13736 case "description":
13737 out.Values[i] = ec.___Type_description(ctx, field, obj)
13738 case "fields":
13739 out.Values[i] = ec.___Type_fields(ctx, field, obj)
13740 case "interfaces":
13741 out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
13742 case "possibleTypes":
13743 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
13744 case "enumValues":
13745 out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
13746 case "inputFields":
13747 out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
13748 case "ofType":
13749 out.Values[i] = ec.___Type_ofType(ctx, field, obj)
13750 default:
13751 panic("unknown field " + strconv.Quote(field.Name))
13752 }
13753 }
13754 out.Dispatch()
13755 if invalids > 0 {
13756 return graphql.Null
13757 }
13758 return out
13759}
13760
13761// endregion **************************** object.gotpl ****************************
13762
13763// region ***************************** type.gotpl *****************************
13764
13765func (ec *executionContext) unmarshalNAddCommentAndCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugInput(ctx context.Context, v interface{}) (models.AddCommentAndCloseBugInput, error) {
13766 return ec.unmarshalInputAddCommentAndCloseBugInput(ctx, v)
13767}
13768
13769func (ec *executionContext) marshalNAddCommentAndCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentAndCloseBugPayload) graphql.Marshaler {
13770 return ec._AddCommentAndCloseBugPayload(ctx, sel, &v)
13771}
13772
13773func (ec *executionContext) marshalNAddCommentAndCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentAndCloseBugPayload) graphql.Marshaler {
13774 if v == nil {
13775 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13776 ec.Errorf(ctx, "must not be null")
13777 }
13778 return graphql.Null
13779 }
13780 return ec._AddCommentAndCloseBugPayload(ctx, sel, v)
13781}
13782
13783func (ec *executionContext) unmarshalNAddCommentAndReopenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugInput(ctx context.Context, v interface{}) (models.AddCommentAndReopenBugInput, error) {
13784 return ec.unmarshalInputAddCommentAndReopenBugInput(ctx, v)
13785}
13786
13787func (ec *executionContext) marshalNAddCommentAndReopenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentAndReopenBugPayload) graphql.Marshaler {
13788 return ec._AddCommentAndReopenBugPayload(ctx, sel, &v)
13789}
13790
13791func (ec *executionContext) marshalNAddCommentAndReopenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentAndReopenBugPayload) graphql.Marshaler {
13792 if v == nil {
13793 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13794 ec.Errorf(ctx, "must not be null")
13795 }
13796 return graphql.Null
13797 }
13798 return ec._AddCommentAndReopenBugPayload(ctx, sel, v)
13799}
13800
13801func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
13802 return ec.unmarshalInputAddCommentInput(ctx, v)
13803}
13804
13805func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
13806 return ec._AddCommentOperation(ctx, sel, &v)
13807}
13808
13809func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
13810 if v == nil {
13811 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13812 ec.Errorf(ctx, "must not be null")
13813 }
13814 return graphql.Null
13815 }
13816 return ec._AddCommentOperation(ctx, sel, v)
13817}
13818
13819func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
13820 return ec._AddCommentPayload(ctx, sel, &v)
13821}
13822
13823func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
13824 if v == nil {
13825 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13826 ec.Errorf(ctx, "must not be null")
13827 }
13828 return graphql.Null
13829 }
13830 return ec._AddCommentPayload(ctx, sel, v)
13831}
13832
13833func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
13834 return graphql.UnmarshalBoolean(v)
13835}
13836
13837func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
13838 res := graphql.MarshalBoolean(v)
13839 if res == graphql.Null {
13840 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13841 ec.Errorf(ctx, "must not be null")
13842 }
13843 }
13844 return res
13845}
13846
13847func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
13848 if v == nil {
13849 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13850 ec.Errorf(ctx, "must not be null")
13851 }
13852 return graphql.Null
13853 }
13854 return ec._Bug(ctx, sel, v)
13855}
13856
13857func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
13858 ret := make(graphql.Array, len(v))
13859 var wg sync.WaitGroup
13860 isLen1 := len(v) == 1
13861 if !isLen1 {
13862 wg.Add(len(v))
13863 }
13864 for i := range v {
13865 i := i
13866 fc := &graphql.FieldContext{
13867 Index: &i,
13868 Result: &v[i],
13869 }
13870 ctx := graphql.WithFieldContext(ctx, fc)
13871 f := func(i int) {
13872 defer func() {
13873 if r := recover(); r != nil {
13874 ec.Error(ctx, ec.Recover(ctx, r))
13875 ret = nil
13876 }
13877 }()
13878 if !isLen1 {
13879 defer wg.Done()
13880 }
13881 ret[i] = ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
13882 }
13883 if isLen1 {
13884 f(i)
13885 } else {
13886 go f(i)
13887 }
13888
13889 }
13890 wg.Wait()
13891 return ret
13892}
13893
13894func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
13895 return ec._BugConnection(ctx, sel, &v)
13896}
13897
13898func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
13899 if v == nil {
13900 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13901 ec.Errorf(ctx, "must not be null")
13902 }
13903 return graphql.Null
13904 }
13905 return ec._BugConnection(ctx, sel, v)
13906}
13907
13908func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
13909 return ec._BugEdge(ctx, sel, &v)
13910}
13911
13912func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
13913 ret := make(graphql.Array, len(v))
13914 var wg sync.WaitGroup
13915 isLen1 := len(v) == 1
13916 if !isLen1 {
13917 wg.Add(len(v))
13918 }
13919 for i := range v {
13920 i := i
13921 fc := &graphql.FieldContext{
13922 Index: &i,
13923 Result: &v[i],
13924 }
13925 ctx := graphql.WithFieldContext(ctx, fc)
13926 f := func(i int) {
13927 defer func() {
13928 if r := recover(); r != nil {
13929 ec.Error(ctx, ec.Recover(ctx, r))
13930 ret = nil
13931 }
13932 }()
13933 if !isLen1 {
13934 defer wg.Done()
13935 }
13936 ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
13937 }
13938 if isLen1 {
13939 f(i)
13940 } else {
13941 go f(i)
13942 }
13943
13944 }
13945 wg.Wait()
13946 return ret
13947}
13948
13949func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
13950 if v == nil {
13951 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13952 ec.Errorf(ctx, "must not be null")
13953 }
13954 return graphql.Null
13955 }
13956 return ec._BugEdge(ctx, sel, v)
13957}
13958
13959func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
13960 return ec._ChangeLabelPayload(ctx, sel, &v)
13961}
13962
13963func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
13964 if v == nil {
13965 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13966 ec.Errorf(ctx, "must not be null")
13967 }
13968 return graphql.Null
13969 }
13970 return ec._ChangeLabelPayload(ctx, sel, v)
13971}
13972
13973func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
13974 return ec.unmarshalInputCloseBugInput(ctx, v)
13975}
13976
13977func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
13978 return ec._CloseBugPayload(ctx, sel, &v)
13979}
13980
13981func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
13982 if v == nil {
13983 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13984 ec.Errorf(ctx, "must not be null")
13985 }
13986 return graphql.Null
13987 }
13988 return ec._CloseBugPayload(ctx, sel, v)
13989}
13990
13991func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
13992 return ec._Color(ctx, sel, &v)
13993}
13994
13995func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
13996 if v == nil {
13997 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13998 ec.Errorf(ctx, "must not be null")
13999 }
14000 return graphql.Null
14001 }
14002 return ec._Color(ctx, sel, v)
14003}
14004
14005func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
14006 return ec._Comment(ctx, sel, &v)
14007}
14008
14009func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
14010 ret := make(graphql.Array, len(v))
14011 var wg sync.WaitGroup
14012 isLen1 := len(v) == 1
14013 if !isLen1 {
14014 wg.Add(len(v))
14015 }
14016 for i := range v {
14017 i := i
14018 fc := &graphql.FieldContext{
14019 Index: &i,
14020 Result: &v[i],
14021 }
14022 ctx := graphql.WithFieldContext(ctx, fc)
14023 f := func(i int) {
14024 defer func() {
14025 if r := recover(); r != nil {
14026 ec.Error(ctx, ec.Recover(ctx, r))
14027 ret = nil
14028 }
14029 }()
14030 if !isLen1 {
14031 defer wg.Done()
14032 }
14033 ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
14034 }
14035 if isLen1 {
14036 f(i)
14037 } else {
14038 go f(i)
14039 }
14040
14041 }
14042 wg.Wait()
14043 return ret
14044}
14045
14046func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
14047 if v == nil {
14048 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14049 ec.Errorf(ctx, "must not be null")
14050 }
14051 return graphql.Null
14052 }
14053 return ec._Comment(ctx, sel, v)
14054}
14055
14056func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
14057 return ec._CommentConnection(ctx, sel, &v)
14058}
14059
14060func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
14061 if v == nil {
14062 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14063 ec.Errorf(ctx, "must not be null")
14064 }
14065 return graphql.Null
14066 }
14067 return ec._CommentConnection(ctx, sel, v)
14068}
14069
14070func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
14071 return ec._CommentEdge(ctx, sel, &v)
14072}
14073
14074func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
14075 ret := make(graphql.Array, len(v))
14076 var wg sync.WaitGroup
14077 isLen1 := len(v) == 1
14078 if !isLen1 {
14079 wg.Add(len(v))
14080 }
14081 for i := range v {
14082 i := i
14083 fc := &graphql.FieldContext{
14084 Index: &i,
14085 Result: &v[i],
14086 }
14087 ctx := graphql.WithFieldContext(ctx, fc)
14088 f := func(i int) {
14089 defer func() {
14090 if r := recover(); r != nil {
14091 ec.Error(ctx, ec.Recover(ctx, r))
14092 ret = nil
14093 }
14094 }()
14095 if !isLen1 {
14096 defer wg.Done()
14097 }
14098 ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
14099 }
14100 if isLen1 {
14101 f(i)
14102 } else {
14103 go f(i)
14104 }
14105
14106 }
14107 wg.Wait()
14108 return ret
14109}
14110
14111func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
14112 if v == nil {
14113 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14114 ec.Errorf(ctx, "must not be null")
14115 }
14116 return graphql.Null
14117 }
14118 return ec._CommentEdge(ctx, sel, v)
14119}
14120
14121func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
14122 return ec._CommentHistoryStep(ctx, sel, &v)
14123}
14124
14125func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
14126 ret := make(graphql.Array, len(v))
14127 var wg sync.WaitGroup
14128 isLen1 := len(v) == 1
14129 if !isLen1 {
14130 wg.Add(len(v))
14131 }
14132 for i := range v {
14133 i := i
14134 fc := &graphql.FieldContext{
14135 Index: &i,
14136 Result: &v[i],
14137 }
14138 ctx := graphql.WithFieldContext(ctx, fc)
14139 f := func(i int) {
14140 defer func() {
14141 if r := recover(); r != nil {
14142 ec.Error(ctx, ec.Recover(ctx, r))
14143 ret = nil
14144 }
14145 }()
14146 if !isLen1 {
14147 defer wg.Done()
14148 }
14149 ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
14150 }
14151 if isLen1 {
14152 f(i)
14153 } else {
14154 go f(i)
14155 }
14156
14157 }
14158 wg.Wait()
14159 return ret
14160}
14161
14162func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
14163 return ec._CreateOperation(ctx, sel, &v)
14164}
14165
14166func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
14167 if v == nil {
14168 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14169 ec.Errorf(ctx, "must not be null")
14170 }
14171 return graphql.Null
14172 }
14173 return ec._CreateOperation(ctx, sel, v)
14174}
14175
14176func (ec *executionContext) unmarshalNEditCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx context.Context, v interface{}) (models.EditCommentInput, error) {
14177 return ec.unmarshalInputEditCommentInput(ctx, v)
14178}
14179
14180func (ec *executionContext) marshalNEditCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐEditCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.EditCommentOperation) graphql.Marshaler {
14181 return ec._EditCommentOperation(ctx, sel, &v)
14182}
14183
14184func (ec *executionContext) marshalNEditCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐEditCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.EditCommentOperation) graphql.Marshaler {
14185 if v == nil {
14186 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14187 ec.Errorf(ctx, "must not be null")
14188 }
14189 return graphql.Null
14190 }
14191 return ec._EditCommentOperation(ctx, sel, v)
14192}
14193
14194func (ec *executionContext) marshalNEditCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.EditCommentPayload) graphql.Marshaler {
14195 return ec._EditCommentPayload(ctx, sel, &v)
14196}
14197
14198func (ec *executionContext) marshalNEditCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.EditCommentPayload) graphql.Marshaler {
14199 if v == nil {
14200 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14201 ec.Errorf(ctx, "must not be null")
14202 }
14203 return graphql.Null
14204 }
14205 return ec._EditCommentPayload(ctx, sel, v)
14206}
14207
14208func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx context.Context, v interface{}) (repository.Hash, error) {
14209 var res repository.Hash
14210 return res, res.UnmarshalGQL(v)
14211}
14212
14213func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx context.Context, sel ast.SelectionSet, v repository.Hash) graphql.Marshaler {
14214 return v
14215}
14216
14217func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, v interface{}) ([]repository.Hash, error) {
14218 var vSlice []interface{}
14219 if v != nil {
14220 if tmp1, ok := v.([]interface{}); ok {
14221 vSlice = tmp1
14222 } else {
14223 vSlice = []interface{}{v}
14224 }
14225 }
14226 var err error
14227 res := make([]repository.Hash, len(vSlice))
14228 for i := range vSlice {
14229 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, vSlice[i])
14230 if err != nil {
14231 return nil, err
14232 }
14233 }
14234 return res, nil
14235}
14236
14237func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []repository.Hash) graphql.Marshaler {
14238 ret := make(graphql.Array, len(v))
14239 for i := range v {
14240 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, sel, v[i])
14241 }
14242
14243 return ret
14244}
14245
14246func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
14247 if v == nil {
14248 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14249 ec.Errorf(ctx, "must not be null")
14250 }
14251 return graphql.Null
14252 }
14253 return ec._Identity(ctx, sel, v)
14254}
14255
14256func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.IdentityWrapper) graphql.Marshaler {
14257 ret := make(graphql.Array, len(v))
14258 var wg sync.WaitGroup
14259 isLen1 := len(v) == 1
14260 if !isLen1 {
14261 wg.Add(len(v))
14262 }
14263 for i := range v {
14264 i := i
14265 fc := &graphql.FieldContext{
14266 Index: &i,
14267 Result: &v[i],
14268 }
14269 ctx := graphql.WithFieldContext(ctx, fc)
14270 f := func(i int) {
14271 defer func() {
14272 if r := recover(); r != nil {
14273 ec.Error(ctx, ec.Recover(ctx, r))
14274 ret = nil
14275 }
14276 }()
14277 if !isLen1 {
14278 defer wg.Done()
14279 }
14280 ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, sel, v[i])
14281 }
14282 if isLen1 {
14283 f(i)
14284 } else {
14285 go f(i)
14286 }
14287
14288 }
14289 wg.Wait()
14290 return ret
14291}
14292
14293func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
14294 return ec._IdentityConnection(ctx, sel, &v)
14295}
14296
14297func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
14298 if v == nil {
14299 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14300 ec.Errorf(ctx, "must not be null")
14301 }
14302 return graphql.Null
14303 }
14304 return ec._IdentityConnection(ctx, sel, v)
14305}
14306
14307func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
14308 return ec._IdentityEdge(ctx, sel, &v)
14309}
14310
14311func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
14312 ret := make(graphql.Array, len(v))
14313 var wg sync.WaitGroup
14314 isLen1 := len(v) == 1
14315 if !isLen1 {
14316 wg.Add(len(v))
14317 }
14318 for i := range v {
14319 i := i
14320 fc := &graphql.FieldContext{
14321 Index: &i,
14322 Result: &v[i],
14323 }
14324 ctx := graphql.WithFieldContext(ctx, fc)
14325 f := func(i int) {
14326 defer func() {
14327 if r := recover(); r != nil {
14328 ec.Error(ctx, ec.Recover(ctx, r))
14329 ret = nil
14330 }
14331 }()
14332 if !isLen1 {
14333 defer wg.Done()
14334 }
14335 ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
14336 }
14337 if isLen1 {
14338 f(i)
14339 } else {
14340 go f(i)
14341 }
14342
14343 }
14344 wg.Wait()
14345 return ret
14346}
14347
14348func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
14349 if v == nil {
14350 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14351 ec.Errorf(ctx, "must not be null")
14352 }
14353 return graphql.Null
14354 }
14355 return ec._IdentityEdge(ctx, sel, v)
14356}
14357
14358func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
14359 return graphql.UnmarshalInt(v)
14360}
14361
14362func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14363 res := graphql.MarshalInt(v)
14364 if res == graphql.Null {
14365 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14366 ec.Errorf(ctx, "must not be null")
14367 }
14368 }
14369 return res
14370}
14371
14372func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
14373 return ec._Label(ctx, sel, &v)
14374}
14375
14376func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
14377 ret := make(graphql.Array, len(v))
14378 var wg sync.WaitGroup
14379 isLen1 := len(v) == 1
14380 if !isLen1 {
14381 wg.Add(len(v))
14382 }
14383 for i := range v {
14384 i := i
14385 fc := &graphql.FieldContext{
14386 Index: &i,
14387 Result: &v[i],
14388 }
14389 ctx := graphql.WithFieldContext(ctx, fc)
14390 f := func(i int) {
14391 defer func() {
14392 if r := recover(); r != nil {
14393 ec.Error(ctx, ec.Recover(ctx, r))
14394 ret = nil
14395 }
14396 }()
14397 if !isLen1 {
14398 defer wg.Done()
14399 }
14400 ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
14401 }
14402 if isLen1 {
14403 f(i)
14404 } else {
14405 go f(i)
14406 }
14407
14408 }
14409 wg.Wait()
14410 return ret
14411}
14412
14413func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
14414 return ec._LabelChangeOperation(ctx, sel, &v)
14415}
14416
14417func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
14418 if v == nil {
14419 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14420 ec.Errorf(ctx, "must not be null")
14421 }
14422 return graphql.Null
14423 }
14424 return ec._LabelChangeOperation(ctx, sel, v)
14425}
14426
14427func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
14428 ret := make(graphql.Array, len(v))
14429 var wg sync.WaitGroup
14430 isLen1 := len(v) == 1
14431 if !isLen1 {
14432 wg.Add(len(v))
14433 }
14434 for i := range v {
14435 i := i
14436 fc := &graphql.FieldContext{
14437 Index: &i,
14438 Result: &v[i],
14439 }
14440 ctx := graphql.WithFieldContext(ctx, fc)
14441 f := func(i int) {
14442 defer func() {
14443 if r := recover(); r != nil {
14444 ec.Error(ctx, ec.Recover(ctx, r))
14445 ret = nil
14446 }
14447 }()
14448 if !isLen1 {
14449 defer wg.Done()
14450 }
14451 ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
14452 }
14453 if isLen1 {
14454 f(i)
14455 } else {
14456 go f(i)
14457 }
14458
14459 }
14460 wg.Wait()
14461 return ret
14462}
14463
14464func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
14465 var res models.LabelChangeStatus
14466 return res, res.UnmarshalGQL(v)
14467}
14468
14469func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
14470 return v
14471}
14472
14473func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
14474 return ec._LabelConnection(ctx, sel, &v)
14475}
14476
14477func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
14478 if v == nil {
14479 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14480 ec.Errorf(ctx, "must not be null")
14481 }
14482 return graphql.Null
14483 }
14484 return ec._LabelConnection(ctx, sel, v)
14485}
14486
14487func (ec *executionContext) marshalNLabelEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v models.LabelEdge) graphql.Marshaler {
14488 return ec._LabelEdge(ctx, sel, &v)
14489}
14490
14491func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
14492 ret := make(graphql.Array, len(v))
14493 var wg sync.WaitGroup
14494 isLen1 := len(v) == 1
14495 if !isLen1 {
14496 wg.Add(len(v))
14497 }
14498 for i := range v {
14499 i := i
14500 fc := &graphql.FieldContext{
14501 Index: &i,
14502 Result: &v[i],
14503 }
14504 ctx := graphql.WithFieldContext(ctx, fc)
14505 f := func(i int) {
14506 defer func() {
14507 if r := recover(); r != nil {
14508 ec.Error(ctx, ec.Recover(ctx, r))
14509 ret = nil
14510 }
14511 }()
14512 if !isLen1 {
14513 defer wg.Done()
14514 }
14515 ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
14516 }
14517 if isLen1 {
14518 f(i)
14519 } else {
14520 go f(i)
14521 }
14522
14523 }
14524 wg.Wait()
14525 return ret
14526}
14527
14528func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
14529 if v == nil {
14530 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14531 ec.Errorf(ctx, "must not be null")
14532 }
14533 return graphql.Null
14534 }
14535 return ec._LabelEdge(ctx, sel, v)
14536}
14537
14538func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
14539 return ec.unmarshalInputNewBugInput(ctx, v)
14540}
14541
14542func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
14543 return ec._NewBugPayload(ctx, sel, &v)
14544}
14545
14546func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
14547 if v == nil {
14548 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14549 ec.Errorf(ctx, "must not be null")
14550 }
14551 return graphql.Null
14552 }
14553 return ec._NewBugPayload(ctx, sel, v)
14554}
14555
14556func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
14557 return ec.unmarshalInputOpenBugInput(ctx, v)
14558}
14559
14560func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
14561 return ec._OpenBugPayload(ctx, sel, &v)
14562}
14563
14564func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
14565 if v == nil {
14566 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14567 ec.Errorf(ctx, "must not be null")
14568 }
14569 return graphql.Null
14570 }
14571 return ec._OpenBugPayload(ctx, sel, v)
14572}
14573
14574func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
14575 if v == nil {
14576 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14577 ec.Errorf(ctx, "must not be null")
14578 }
14579 return graphql.Null
14580 }
14581 return ec._Operation(ctx, sel, v)
14582}
14583
14584func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
14585 ret := make(graphql.Array, len(v))
14586 var wg sync.WaitGroup
14587 isLen1 := len(v) == 1
14588 if !isLen1 {
14589 wg.Add(len(v))
14590 }
14591 for i := range v {
14592 i := i
14593 fc := &graphql.FieldContext{
14594 Index: &i,
14595 Result: &v[i],
14596 }
14597 ctx := graphql.WithFieldContext(ctx, fc)
14598 f := func(i int) {
14599 defer func() {
14600 if r := recover(); r != nil {
14601 ec.Error(ctx, ec.Recover(ctx, r))
14602 ret = nil
14603 }
14604 }()
14605 if !isLen1 {
14606 defer wg.Done()
14607 }
14608 ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
14609 }
14610 if isLen1 {
14611 f(i)
14612 } else {
14613 go f(i)
14614 }
14615
14616 }
14617 wg.Wait()
14618 return ret
14619}
14620
14621func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
14622 return ec._OperationConnection(ctx, sel, &v)
14623}
14624
14625func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
14626 if v == nil {
14627 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14628 ec.Errorf(ctx, "must not be null")
14629 }
14630 return graphql.Null
14631 }
14632 return ec._OperationConnection(ctx, sel, v)
14633}
14634
14635func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
14636 return ec._OperationEdge(ctx, sel, &v)
14637}
14638
14639func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
14640 ret := make(graphql.Array, len(v))
14641 var wg sync.WaitGroup
14642 isLen1 := len(v) == 1
14643 if !isLen1 {
14644 wg.Add(len(v))
14645 }
14646 for i := range v {
14647 i := i
14648 fc := &graphql.FieldContext{
14649 Index: &i,
14650 Result: &v[i],
14651 }
14652 ctx := graphql.WithFieldContext(ctx, fc)
14653 f := func(i int) {
14654 defer func() {
14655 if r := recover(); r != nil {
14656 ec.Error(ctx, ec.Recover(ctx, r))
14657 ret = nil
14658 }
14659 }()
14660 if !isLen1 {
14661 defer wg.Done()
14662 }
14663 ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
14664 }
14665 if isLen1 {
14666 f(i)
14667 } else {
14668 go f(i)
14669 }
14670
14671 }
14672 wg.Wait()
14673 return ret
14674}
14675
14676func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
14677 if v == nil {
14678 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14679 ec.Errorf(ctx, "must not be null")
14680 }
14681 return graphql.Null
14682 }
14683 return ec._OperationEdge(ctx, sel, v)
14684}
14685
14686func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
14687 return ec._PageInfo(ctx, sel, &v)
14688}
14689
14690func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
14691 if v == nil {
14692 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14693 ec.Errorf(ctx, "must not be null")
14694 }
14695 return graphql.Null
14696 }
14697 return ec._PageInfo(ctx, sel, v)
14698}
14699
14700func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
14701 return ec._SetStatusOperation(ctx, sel, &v)
14702}
14703
14704func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
14705 if v == nil {
14706 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14707 ec.Errorf(ctx, "must not be null")
14708 }
14709 return graphql.Null
14710 }
14711 return ec._SetStatusOperation(ctx, sel, v)
14712}
14713
14714func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
14715 return ec.unmarshalInputSetTitleInput(ctx, v)
14716}
14717
14718func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
14719 return ec._SetTitleOperation(ctx, sel, &v)
14720}
14721
14722func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
14723 if v == nil {
14724 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14725 ec.Errorf(ctx, "must not be null")
14726 }
14727 return graphql.Null
14728 }
14729 return ec._SetTitleOperation(ctx, sel, v)
14730}
14731
14732func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
14733 return ec._SetTitlePayload(ctx, sel, &v)
14734}
14735
14736func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
14737 if v == nil {
14738 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14739 ec.Errorf(ctx, "must not be null")
14740 }
14741 return graphql.Null
14742 }
14743 return ec._SetTitlePayload(ctx, sel, v)
14744}
14745
14746func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
14747 var res models.Status
14748 return res, res.UnmarshalGQL(v)
14749}
14750
14751func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
14752 return v
14753}
14754
14755func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
14756 return graphql.UnmarshalString(v)
14757}
14758
14759func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14760 res := graphql.MarshalString(v)
14761 if res == graphql.Null {
14762 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14763 ec.Errorf(ctx, "must not be null")
14764 }
14765 }
14766 return res
14767}
14768
14769func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
14770 return graphql.UnmarshalTime(v)
14771}
14772
14773func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
14774 res := graphql.MarshalTime(v)
14775 if res == graphql.Null {
14776 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14777 ec.Errorf(ctx, "must not be null")
14778 }
14779 }
14780 return res
14781}
14782
14783func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
14784 if v == nil {
14785 return nil, nil
14786 }
14787 res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
14788 return &res, err
14789}
14790
14791func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
14792 if v == nil {
14793 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14794 ec.Errorf(ctx, "must not be null")
14795 }
14796 return graphql.Null
14797 }
14798 return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
14799}
14800
14801func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
14802 if v == nil {
14803 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14804 ec.Errorf(ctx, "must not be null")
14805 }
14806 return graphql.Null
14807 }
14808 return ec._TimelineItem(ctx, sel, v)
14809}
14810
14811func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
14812 ret := make(graphql.Array, len(v))
14813 var wg sync.WaitGroup
14814 isLen1 := len(v) == 1
14815 if !isLen1 {
14816 wg.Add(len(v))
14817 }
14818 for i := range v {
14819 i := i
14820 fc := &graphql.FieldContext{
14821 Index: &i,
14822 Result: &v[i],
14823 }
14824 ctx := graphql.WithFieldContext(ctx, fc)
14825 f := func(i int) {
14826 defer func() {
14827 if r := recover(); r != nil {
14828 ec.Error(ctx, ec.Recover(ctx, r))
14829 ret = nil
14830 }
14831 }()
14832 if !isLen1 {
14833 defer wg.Done()
14834 }
14835 ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
14836 }
14837 if isLen1 {
14838 f(i)
14839 } else {
14840 go f(i)
14841 }
14842
14843 }
14844 wg.Wait()
14845 return ret
14846}
14847
14848func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
14849 return ec._TimelineItemConnection(ctx, sel, &v)
14850}
14851
14852func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
14853 if v == nil {
14854 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14855 ec.Errorf(ctx, "must not be null")
14856 }
14857 return graphql.Null
14858 }
14859 return ec._TimelineItemConnection(ctx, sel, v)
14860}
14861
14862func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
14863 return ec._TimelineItemEdge(ctx, sel, &v)
14864}
14865
14866func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
14867 ret := make(graphql.Array, len(v))
14868 var wg sync.WaitGroup
14869 isLen1 := len(v) == 1
14870 if !isLen1 {
14871 wg.Add(len(v))
14872 }
14873 for i := range v {
14874 i := i
14875 fc := &graphql.FieldContext{
14876 Index: &i,
14877 Result: &v[i],
14878 }
14879 ctx := graphql.WithFieldContext(ctx, fc)
14880 f := func(i int) {
14881 defer func() {
14882 if r := recover(); r != nil {
14883 ec.Error(ctx, ec.Recover(ctx, r))
14884 ret = nil
14885 }
14886 }()
14887 if !isLen1 {
14888 defer wg.Done()
14889 }
14890 ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
14891 }
14892 if isLen1 {
14893 f(i)
14894 } else {
14895 go f(i)
14896 }
14897
14898 }
14899 wg.Wait()
14900 return ret
14901}
14902
14903func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
14904 if v == nil {
14905 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14906 ec.Errorf(ctx, "must not be null")
14907 }
14908 return graphql.Null
14909 }
14910 return ec._TimelineItemEdge(ctx, sel, v)
14911}
14912
14913func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
14914 return ec.___Directive(ctx, sel, &v)
14915}
14916
14917func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
14918 ret := make(graphql.Array, len(v))
14919 var wg sync.WaitGroup
14920 isLen1 := len(v) == 1
14921 if !isLen1 {
14922 wg.Add(len(v))
14923 }
14924 for i := range v {
14925 i := i
14926 fc := &graphql.FieldContext{
14927 Index: &i,
14928 Result: &v[i],
14929 }
14930 ctx := graphql.WithFieldContext(ctx, fc)
14931 f := func(i int) {
14932 defer func() {
14933 if r := recover(); r != nil {
14934 ec.Error(ctx, ec.Recover(ctx, r))
14935 ret = nil
14936 }
14937 }()
14938 if !isLen1 {
14939 defer wg.Done()
14940 }
14941 ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
14942 }
14943 if isLen1 {
14944 f(i)
14945 } else {
14946 go f(i)
14947 }
14948
14949 }
14950 wg.Wait()
14951 return ret
14952}
14953
14954func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
14955 return graphql.UnmarshalString(v)
14956}
14957
14958func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14959 res := graphql.MarshalString(v)
14960 if res == graphql.Null {
14961 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14962 ec.Errorf(ctx, "must not be null")
14963 }
14964 }
14965 return res
14966}
14967
14968func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14969 var vSlice []interface{}
14970 if v != nil {
14971 if tmp1, ok := v.([]interface{}); ok {
14972 vSlice = tmp1
14973 } else {
14974 vSlice = []interface{}{v}
14975 }
14976 }
14977 var err error
14978 res := make([]string, len(vSlice))
14979 for i := range vSlice {
14980 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
14981 if err != nil {
14982 return nil, err
14983 }
14984 }
14985 return res, nil
14986}
14987
14988func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14989 ret := make(graphql.Array, len(v))
14990 var wg sync.WaitGroup
14991 isLen1 := len(v) == 1
14992 if !isLen1 {
14993 wg.Add(len(v))
14994 }
14995 for i := range v {
14996 i := i
14997 fc := &graphql.FieldContext{
14998 Index: &i,
14999 Result: &v[i],
15000 }
15001 ctx := graphql.WithFieldContext(ctx, fc)
15002 f := func(i int) {
15003 defer func() {
15004 if r := recover(); r != nil {
15005 ec.Error(ctx, ec.Recover(ctx, r))
15006 ret = nil
15007 }
15008 }()
15009 if !isLen1 {
15010 defer wg.Done()
15011 }
15012 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
15013 }
15014 if isLen1 {
15015 f(i)
15016 } else {
15017 go f(i)
15018 }
15019
15020 }
15021 wg.Wait()
15022 return ret
15023}
15024
15025func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
15026 return ec.___EnumValue(ctx, sel, &v)
15027}
15028
15029func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
15030 return ec.___Field(ctx, sel, &v)
15031}
15032
15033func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
15034 return ec.___InputValue(ctx, sel, &v)
15035}
15036
15037func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
15038 ret := make(graphql.Array, len(v))
15039 var wg sync.WaitGroup
15040 isLen1 := len(v) == 1
15041 if !isLen1 {
15042 wg.Add(len(v))
15043 }
15044 for i := range v {
15045 i := i
15046 fc := &graphql.FieldContext{
15047 Index: &i,
15048 Result: &v[i],
15049 }
15050 ctx := graphql.WithFieldContext(ctx, fc)
15051 f := func(i int) {
15052 defer func() {
15053 if r := recover(); r != nil {
15054 ec.Error(ctx, ec.Recover(ctx, r))
15055 ret = nil
15056 }
15057 }()
15058 if !isLen1 {
15059 defer wg.Done()
15060 }
15061 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
15062 }
15063 if isLen1 {
15064 f(i)
15065 } else {
15066 go f(i)
15067 }
15068
15069 }
15070 wg.Wait()
15071 return ret
15072}
15073
15074func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
15075 return ec.___Type(ctx, sel, &v)
15076}
15077
15078func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
15079 ret := make(graphql.Array, len(v))
15080 var wg sync.WaitGroup
15081 isLen1 := len(v) == 1
15082 if !isLen1 {
15083 wg.Add(len(v))
15084 }
15085 for i := range v {
15086 i := i
15087 fc := &graphql.FieldContext{
15088 Index: &i,
15089 Result: &v[i],
15090 }
15091 ctx := graphql.WithFieldContext(ctx, fc)
15092 f := func(i int) {
15093 defer func() {
15094 if r := recover(); r != nil {
15095 ec.Error(ctx, ec.Recover(ctx, r))
15096 ret = nil
15097 }
15098 }()
15099 if !isLen1 {
15100 defer wg.Done()
15101 }
15102 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
15103 }
15104 if isLen1 {
15105 f(i)
15106 } else {
15107 go f(i)
15108 }
15109
15110 }
15111 wg.Wait()
15112 return ret
15113}
15114
15115func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
15116 if v == nil {
15117 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15118 ec.Errorf(ctx, "must not be null")
15119 }
15120 return graphql.Null
15121 }
15122 return ec.___Type(ctx, sel, v)
15123}
15124
15125func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
15126 return graphql.UnmarshalString(v)
15127}
15128
15129func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
15130 res := graphql.MarshalString(v)
15131 if res == graphql.Null {
15132 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
15133 ec.Errorf(ctx, "must not be null")
15134 }
15135 }
15136 return res
15137}
15138
15139func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
15140 return graphql.UnmarshalBoolean(v)
15141}
15142
15143func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
15144 return graphql.MarshalBoolean(v)
15145}
15146
15147func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
15148 if v == nil {
15149 return nil, nil
15150 }
15151 res, err := ec.unmarshalOBoolean2bool(ctx, v)
15152 return &res, err
15153}
15154
15155func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
15156 if v == nil {
15157 return graphql.Null
15158 }
15159 return ec.marshalOBoolean2bool(ctx, sel, *v)
15160}
15161
15162func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
15163 if v == nil {
15164 return graphql.Null
15165 }
15166 return ec._Bug(ctx, sel, v)
15167}
15168
15169func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
15170 return ec.unmarshalInputChangeLabelInput(ctx, v)
15171}
15172
15173func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
15174 if v == nil {
15175 return nil, nil
15176 }
15177 res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
15178 return &res, err
15179}
15180
15181func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, v interface{}) ([]repository.Hash, error) {
15182 var vSlice []interface{}
15183 if v != nil {
15184 if tmp1, ok := v.([]interface{}); ok {
15185 vSlice = tmp1
15186 } else {
15187 vSlice = []interface{}{v}
15188 }
15189 }
15190 var err error
15191 res := make([]repository.Hash, len(vSlice))
15192 for i := range vSlice {
15193 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, vSlice[i])
15194 if err != nil {
15195 return nil, err
15196 }
15197 }
15198 return res, nil
15199}
15200
15201func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []repository.Hash) graphql.Marshaler {
15202 if v == nil {
15203 return graphql.Null
15204 }
15205 ret := make(graphql.Array, len(v))
15206 for i := range v {
15207 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, sel, v[i])
15208 }
15209
15210 return ret
15211}
15212
15213func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
15214 if v == nil {
15215 return graphql.Null
15216 }
15217 return ec._Identity(ctx, sel, v)
15218}
15219
15220func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
15221 return graphql.UnmarshalInt(v)
15222}
15223
15224func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
15225 return graphql.MarshalInt(v)
15226}
15227
15228func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
15229 if v == nil {
15230 return nil, nil
15231 }
15232 res, err := ec.unmarshalOInt2int(ctx, v)
15233 return &res, err
15234}
15235
15236func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
15237 if v == nil {
15238 return graphql.Null
15239 }
15240 return ec.marshalOInt2int(ctx, sel, *v)
15241}
15242
15243func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
15244 return ec._LabelChangeResult(ctx, sel, &v)
15245}
15246
15247func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
15248 if v == nil {
15249 return graphql.Null
15250 }
15251 return ec._LabelChangeResult(ctx, sel, v)
15252}
15253
15254func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
15255 return ec._Repository(ctx, sel, &v)
15256}
15257
15258func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
15259 if v == nil {
15260 return graphql.Null
15261 }
15262 return ec._Repository(ctx, sel, v)
15263}
15264
15265func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
15266 return graphql.UnmarshalString(v)
15267}
15268
15269func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
15270 return graphql.MarshalString(v)
15271}
15272
15273func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
15274 var vSlice []interface{}
15275 if v != nil {
15276 if tmp1, ok := v.([]interface{}); ok {
15277 vSlice = tmp1
15278 } else {
15279 vSlice = []interface{}{v}
15280 }
15281 }
15282 var err error
15283 res := make([]string, len(vSlice))
15284 for i := range vSlice {
15285 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
15286 if err != nil {
15287 return nil, err
15288 }
15289 }
15290 return res, nil
15291}
15292
15293func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
15294 if v == nil {
15295 return graphql.Null
15296 }
15297 ret := make(graphql.Array, len(v))
15298 for i := range v {
15299 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
15300 }
15301
15302 return ret
15303}
15304
15305func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
15306 if v == nil {
15307 return nil, nil
15308 }
15309 res, err := ec.unmarshalOString2string(ctx, v)
15310 return &res, err
15311}
15312
15313func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
15314 if v == nil {
15315 return graphql.Null
15316 }
15317 return ec.marshalOString2string(ctx, sel, *v)
15318}
15319
15320func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
15321 if v == nil {
15322 return graphql.Null
15323 }
15324 ret := make(graphql.Array, len(v))
15325 var wg sync.WaitGroup
15326 isLen1 := len(v) == 1
15327 if !isLen1 {
15328 wg.Add(len(v))
15329 }
15330 for i := range v {
15331 i := i
15332 fc := &graphql.FieldContext{
15333 Index: &i,
15334 Result: &v[i],
15335 }
15336 ctx := graphql.WithFieldContext(ctx, fc)
15337 f := func(i int) {
15338 defer func() {
15339 if r := recover(); r != nil {
15340 ec.Error(ctx, ec.Recover(ctx, r))
15341 ret = nil
15342 }
15343 }()
15344 if !isLen1 {
15345 defer wg.Done()
15346 }
15347 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
15348 }
15349 if isLen1 {
15350 f(i)
15351 } else {
15352 go f(i)
15353 }
15354
15355 }
15356 wg.Wait()
15357 return ret
15358}
15359
15360func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
15361 if v == nil {
15362 return graphql.Null
15363 }
15364 ret := make(graphql.Array, len(v))
15365 var wg sync.WaitGroup
15366 isLen1 := len(v) == 1
15367 if !isLen1 {
15368 wg.Add(len(v))
15369 }
15370 for i := range v {
15371 i := i
15372 fc := &graphql.FieldContext{
15373 Index: &i,
15374 Result: &v[i],
15375 }
15376 ctx := graphql.WithFieldContext(ctx, fc)
15377 f := func(i int) {
15378 defer func() {
15379 if r := recover(); r != nil {
15380 ec.Error(ctx, ec.Recover(ctx, r))
15381 ret = nil
15382 }
15383 }()
15384 if !isLen1 {
15385 defer wg.Done()
15386 }
15387 ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
15388 }
15389 if isLen1 {
15390 f(i)
15391 } else {
15392 go f(i)
15393 }
15394
15395 }
15396 wg.Wait()
15397 return ret
15398}
15399
15400func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
15401 if v == nil {
15402 return graphql.Null
15403 }
15404 ret := make(graphql.Array, len(v))
15405 var wg sync.WaitGroup
15406 isLen1 := len(v) == 1
15407 if !isLen1 {
15408 wg.Add(len(v))
15409 }
15410 for i := range v {
15411 i := i
15412 fc := &graphql.FieldContext{
15413 Index: &i,
15414 Result: &v[i],
15415 }
15416 ctx := graphql.WithFieldContext(ctx, fc)
15417 f := func(i int) {
15418 defer func() {
15419 if r := recover(); r != nil {
15420 ec.Error(ctx, ec.Recover(ctx, r))
15421 ret = nil
15422 }
15423 }()
15424 if !isLen1 {
15425 defer wg.Done()
15426 }
15427 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
15428 }
15429 if isLen1 {
15430 f(i)
15431 } else {
15432 go f(i)
15433 }
15434
15435 }
15436 wg.Wait()
15437 return ret
15438}
15439
15440func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
15441 return ec.___Schema(ctx, sel, &v)
15442}
15443
15444func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
15445 if v == nil {
15446 return graphql.Null
15447 }
15448 return ec.___Schema(ctx, sel, v)
15449}
15450
15451func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
15452 return ec.___Type(ctx, sel, &v)
15453}
15454
15455func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
15456 if v == nil {
15457 return graphql.Null
15458 }
15459 ret := make(graphql.Array, len(v))
15460 var wg sync.WaitGroup
15461 isLen1 := len(v) == 1
15462 if !isLen1 {
15463 wg.Add(len(v))
15464 }
15465 for i := range v {
15466 i := i
15467 fc := &graphql.FieldContext{
15468 Index: &i,
15469 Result: &v[i],
15470 }
15471 ctx := graphql.WithFieldContext(ctx, fc)
15472 f := func(i int) {
15473 defer func() {
15474 if r := recover(); r != nil {
15475 ec.Error(ctx, ec.Recover(ctx, r))
15476 ret = nil
15477 }
15478 }()
15479 if !isLen1 {
15480 defer wg.Done()
15481 }
15482 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
15483 }
15484 if isLen1 {
15485 f(i)
15486 } else {
15487 go f(i)
15488 }
15489
15490 }
15491 wg.Wait()
15492 return ret
15493}
15494
15495func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
15496 if v == nil {
15497 return graphql.Null
15498 }
15499 return ec.___Type(ctx, sel, v)
15500}
15501
15502// endregion ***************************** type.gotpl *****************************