1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
2
3package graph
4
5import (
6 "bytes"
7 "context"
8 "errors"
9 "fmt"
10 "image/color"
11 "strconv"
12 "sync"
13 "sync/atomic"
14 "time"
15
16 "github.com/99designs/gqlgen/graphql"
17 "github.com/99designs/gqlgen/graphql/introspection"
18 "github.com/MichaelMure/git-bug/bug"
19 "github.com/MichaelMure/git-bug/graphql/models"
20 "github.com/MichaelMure/git-bug/util/git"
21 "github.com/vektah/gqlparser"
22 "github.com/vektah/gqlparser/ast"
23)
24
25// region ************************** generated!.gotpl **************************
26
27// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
28func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
29 return &executableSchema{
30 resolvers: cfg.Resolvers,
31 directives: cfg.Directives,
32 complexity: cfg.Complexity,
33 }
34}
35
36type Config struct {
37 Resolvers ResolverRoot
38 Directives DirectiveRoot
39 Complexity ComplexityRoot
40}
41
42type ResolverRoot interface {
43 AddCommentOperation() AddCommentOperationResolver
44 AddCommentTimelineItem() AddCommentTimelineItemResolver
45 Bug() BugResolver
46 Color() ColorResolver
47 Comment() CommentResolver
48 CommentHistoryStep() CommentHistoryStepResolver
49 CreateOperation() CreateOperationResolver
50 CreateTimelineItem() CreateTimelineItemResolver
51 EditCommentOperation() EditCommentOperationResolver
52 Identity() IdentityResolver
53 Label() LabelResolver
54 LabelChangeOperation() LabelChangeOperationResolver
55 LabelChangeResult() LabelChangeResultResolver
56 LabelChangeTimelineItem() LabelChangeTimelineItemResolver
57 Mutation() MutationResolver
58 Query() QueryResolver
59 Repository() RepositoryResolver
60 SetStatusOperation() SetStatusOperationResolver
61 SetStatusTimelineItem() SetStatusTimelineItemResolver
62 SetTitleOperation() SetTitleOperationResolver
63 SetTitleTimelineItem() SetTitleTimelineItemResolver
64}
65
66type DirectiveRoot struct {
67}
68
69type ComplexityRoot struct {
70 AddCommentOperation struct {
71 Author func(childComplexity int) int
72 Date func(childComplexity int) int
73 Files func(childComplexity int) int
74 ID func(childComplexity int) int
75 Message func(childComplexity int) int
76 }
77
78 AddCommentPayload struct {
79 Bug func(childComplexity int) int
80 ClientMutationID func(childComplexity int) int
81 Operation func(childComplexity int) int
82 }
83
84 AddCommentTimelineItem struct {
85 Author func(childComplexity int) int
86 CreatedAt func(childComplexity int) int
87 Edited func(childComplexity int) int
88 Files func(childComplexity int) int
89 History func(childComplexity int) int
90 ID func(childComplexity int) int
91 LastEdit func(childComplexity int) int
92 Message func(childComplexity int) int
93 MessageIsEmpty func(childComplexity int) int
94 }
95
96 Bug struct {
97 Actors func(childComplexity int, after *string, before *string, first *int, last *int) int
98 Author func(childComplexity int) int
99 Comments func(childComplexity int, after *string, before *string, first *int, last *int) int
100 CreatedAt func(childComplexity int) int
101 HumanID func(childComplexity int) int
102 ID func(childComplexity int) int
103 Labels func(childComplexity int) int
104 LastEdit func(childComplexity int) int
105 Operations func(childComplexity int, after *string, before *string, first *int, last *int) int
106 Participants func(childComplexity int, after *string, before *string, first *int, last *int) int
107 Status func(childComplexity int) int
108 Timeline func(childComplexity int, after *string, before *string, first *int, last *int) int
109 Title func(childComplexity int) int
110 }
111
112 BugConnection struct {
113 Edges func(childComplexity int) int
114 Nodes func(childComplexity int) int
115 PageInfo func(childComplexity int) int
116 TotalCount func(childComplexity int) int
117 }
118
119 BugEdge struct {
120 Cursor func(childComplexity int) int
121 Node func(childComplexity int) int
122 }
123
124 ChangeLabelPayload struct {
125 Bug func(childComplexity int) int
126 ClientMutationID func(childComplexity int) int
127 Operation func(childComplexity int) int
128 Results func(childComplexity int) int
129 }
130
131 CloseBugPayload struct {
132 Bug func(childComplexity int) int
133 ClientMutationID func(childComplexity int) int
134 Operation func(childComplexity int) int
135 }
136
137 Color struct {
138 B func(childComplexity int) int
139 G func(childComplexity int) int
140 R func(childComplexity int) int
141 }
142
143 Comment struct {
144 Author func(childComplexity int) int
145 Files func(childComplexity int) int
146 Message func(childComplexity int) int
147 }
148
149 CommentConnection struct {
150 Edges func(childComplexity int) int
151 Nodes func(childComplexity int) int
152 PageInfo func(childComplexity int) int
153 TotalCount func(childComplexity int) int
154 }
155
156 CommentEdge struct {
157 Cursor func(childComplexity int) int
158 Node func(childComplexity int) int
159 }
160
161 CommentHistoryStep struct {
162 Date func(childComplexity int) int
163 Message func(childComplexity int) int
164 }
165
166 CommitPayload struct {
167 Bug func(childComplexity int) int
168 ClientMutationID func(childComplexity int) int
169 ID func(childComplexity int) int
170 }
171
172 CreateOperation struct {
173 Author func(childComplexity int) int
174 Date func(childComplexity int) int
175 Files func(childComplexity int) int
176 ID func(childComplexity int) int
177 Message func(childComplexity int) int
178 Title func(childComplexity int) int
179 }
180
181 CreateTimelineItem struct {
182 Author func(childComplexity int) int
183 CreatedAt func(childComplexity int) int
184 Edited func(childComplexity int) int
185 Files func(childComplexity int) int
186 History func(childComplexity int) int
187 ID func(childComplexity int) int
188 LastEdit func(childComplexity int) int
189 Message func(childComplexity int) int
190 MessageIsEmpty func(childComplexity int) int
191 }
192
193 EditCommentOperation struct {
194 Author func(childComplexity int) int
195 Date func(childComplexity int) int
196 Files func(childComplexity int) int
197 ID func(childComplexity int) int
198 Message func(childComplexity int) int
199 Target func(childComplexity int) int
200 }
201
202 Identity struct {
203 AvatarUrl func(childComplexity int) int
204 DisplayName func(childComplexity int) int
205 Email func(childComplexity int) int
206 HumanID func(childComplexity int) int
207 ID func(childComplexity int) int
208 IsProtected func(childComplexity int) int
209 Name func(childComplexity int) int
210 }
211
212 IdentityConnection struct {
213 Edges func(childComplexity int) int
214 Nodes func(childComplexity int) int
215 PageInfo func(childComplexity int) int
216 TotalCount func(childComplexity int) int
217 }
218
219 IdentityEdge struct {
220 Cursor func(childComplexity int) int
221 Node func(childComplexity int) int
222 }
223
224 Label struct {
225 Color func(childComplexity int) int
226 Name func(childComplexity int) int
227 }
228
229 LabelChangeOperation struct {
230 Added func(childComplexity int) int
231 Author func(childComplexity int) int
232 Date func(childComplexity int) int
233 ID func(childComplexity int) int
234 Removed func(childComplexity int) int
235 }
236
237 LabelChangeResult struct {
238 Label func(childComplexity int) int
239 Status func(childComplexity int) int
240 }
241
242 LabelChangeTimelineItem struct {
243 Added func(childComplexity int) int
244 Author func(childComplexity int) int
245 Date func(childComplexity int) int
246 ID func(childComplexity int) int
247 Removed func(childComplexity int) int
248 }
249
250 LabelConnection struct {
251 Edges func(childComplexity int) int
252 Nodes func(childComplexity int) int
253 PageInfo func(childComplexity int) int
254 TotalCount func(childComplexity int) int
255 }
256
257 LabelEdge struct {
258 Cursor func(childComplexity int) int
259 Node func(childComplexity int) int
260 }
261
262 Mutation struct {
263 AddComment func(childComplexity int, input models.AddCommentInput, txID *string) int
264 ChangeLabels func(childComplexity int, input models.ChangeLabelInput, txID *string) int
265 CloseBug func(childComplexity int, input models.CloseBugInput, txID *string) int
266 Commit func(childComplexity int, input models.CommitInput) int
267 NewBug func(childComplexity int, input models.NewBugInput, txID *string) int
268 OpenBug func(childComplexity int, input models.OpenBugInput, txID *string) int
269 Rollback func(childComplexity int, input models.RollbackInput) int
270 SetTitle func(childComplexity int, input models.SetTitleInput, txID *string) int
271 StartTransaction func(childComplexity int, input models.StartTransactionInput) int
272 }
273
274 NewBugPayload struct {
275 Bug func(childComplexity int) int
276 ClientMutationID func(childComplexity int) int
277 Operation func(childComplexity int) int
278 }
279
280 OpenBugPayload struct {
281 Bug func(childComplexity int) int
282 ClientMutationID func(childComplexity int) int
283 Operation func(childComplexity int) int
284 }
285
286 OperationConnection struct {
287 Edges func(childComplexity int) int
288 Nodes func(childComplexity int) int
289 PageInfo func(childComplexity int) int
290 TotalCount func(childComplexity int) int
291 }
292
293 OperationEdge struct {
294 Cursor func(childComplexity int) int
295 Node func(childComplexity int) int
296 }
297
298 PageInfo struct {
299 EndCursor func(childComplexity int) int
300 HasNextPage func(childComplexity int) int
301 HasPreviousPage func(childComplexity int) int
302 StartCursor func(childComplexity int) int
303 }
304
305 Query struct {
306 Repository func(childComplexity int, ref *string) int
307 }
308
309 Repository struct {
310 AllBugs func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
311 AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
312 Bug func(childComplexity int, prefix string) int
313 Identity func(childComplexity int, prefix string) int
314 Name func(childComplexity int) int
315 UserIdentity func(childComplexity int) int
316 ValidLabels func(childComplexity int, after *string, before *string, first *int, last *int) int
317 }
318
319 RollbackPayload struct {
320 Bug func(childComplexity int) int
321 ClientMutationID func(childComplexity int) int
322 ID func(childComplexity int) int
323 }
324
325 SetStatusOperation struct {
326 Author func(childComplexity int) int
327 Date func(childComplexity int) int
328 ID func(childComplexity int) int
329 Status func(childComplexity int) int
330 }
331
332 SetStatusTimelineItem struct {
333 Author func(childComplexity int) int
334 Date func(childComplexity int) int
335 ID func(childComplexity int) int
336 Status func(childComplexity int) int
337 }
338
339 SetTitleOperation struct {
340 Author func(childComplexity int) int
341 Date func(childComplexity int) int
342 ID func(childComplexity int) int
343 Title func(childComplexity int) int
344 Was func(childComplexity int) int
345 }
346
347 SetTitlePayload struct {
348 Bug func(childComplexity int) int
349 ClientMutationID func(childComplexity int) int
350 Operation func(childComplexity int) int
351 }
352
353 SetTitleTimelineItem struct {
354 Author func(childComplexity int) int
355 Date func(childComplexity int) int
356 ID func(childComplexity int) int
357 Title func(childComplexity int) int
358 Was func(childComplexity int) int
359 }
360
361 StartTransactionPayload struct {
362 ClientMutationID func(childComplexity int) int
363 ID func(childComplexity int) int
364 }
365
366 TimelineItemConnection struct {
367 Edges func(childComplexity int) int
368 Nodes func(childComplexity int) int
369 PageInfo func(childComplexity int) int
370 TotalCount func(childComplexity int) int
371 }
372
373 TimelineItemEdge struct {
374 Cursor func(childComplexity int) int
375 Node func(childComplexity int) int
376 }
377}
378
379type AddCommentOperationResolver interface {
380 ID(ctx context.Context, obj *bug.AddCommentOperation) (string, error)
381 Author(ctx context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error)
382 Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
383}
384type AddCommentTimelineItemResolver interface {
385 ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (string, error)
386 Author(ctx context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, error)
387
388 CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
389 LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
390}
391type BugResolver interface {
392 ID(ctx context.Context, obj models.BugWrapper) (string, error)
393 HumanID(ctx context.Context, obj models.BugWrapper) (string, error)
394 Status(ctx context.Context, obj models.BugWrapper) (models.Status, error)
395
396 Actors(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
397 Participants(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
398 Comments(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
399 Timeline(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
400 Operations(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
401}
402type ColorResolver interface {
403 R(ctx context.Context, obj *color.RGBA) (int, error)
404 G(ctx context.Context, obj *color.RGBA) (int, error)
405 B(ctx context.Context, obj *color.RGBA) (int, error)
406}
407type CommentResolver interface {
408 Author(ctx context.Context, obj *bug.Comment) (models.IdentityWrapper, error)
409}
410type CommentHistoryStepResolver interface {
411 Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
412}
413type CreateOperationResolver interface {
414 ID(ctx context.Context, obj *bug.CreateOperation) (string, error)
415 Author(ctx context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error)
416 Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
417}
418type CreateTimelineItemResolver interface {
419 ID(ctx context.Context, obj *bug.CreateTimelineItem) (string, error)
420 Author(ctx context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error)
421
422 CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
423 LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
424}
425type EditCommentOperationResolver interface {
426 ID(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
427 Author(ctx context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error)
428 Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
429 Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
430}
431type IdentityResolver interface {
432 ID(ctx context.Context, obj models.IdentityWrapper) (string, error)
433 HumanID(ctx context.Context, obj models.IdentityWrapper) (string, error)
434}
435type LabelResolver interface {
436 Name(ctx context.Context, obj *bug.Label) (string, error)
437 Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
438}
439type LabelChangeOperationResolver interface {
440 ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
441 Author(ctx context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error)
442 Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
443}
444type LabelChangeResultResolver interface {
445 Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
446}
447type LabelChangeTimelineItemResolver interface {
448 ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
449 Author(ctx context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error)
450 Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
451}
452type MutationResolver interface {
453 NewBug(ctx context.Context, input models.NewBugInput, txID *string) (*models.NewBugPayload, error)
454 AddComment(ctx context.Context, input models.AddCommentInput, txID *string) (*models.AddCommentPayload, error)
455 ChangeLabels(ctx context.Context, input models.ChangeLabelInput, txID *string) (*models.ChangeLabelPayload, error)
456 OpenBug(ctx context.Context, input models.OpenBugInput, txID *string) (*models.OpenBugPayload, error)
457 CloseBug(ctx context.Context, input models.CloseBugInput, txID *string) (*models.CloseBugPayload, error)
458 SetTitle(ctx context.Context, input models.SetTitleInput, txID *string) (*models.SetTitlePayload, error)
459 StartTransaction(ctx context.Context, input models.StartTransactionInput) (*models.StartTransactionPayload, error)
460 Commit(ctx context.Context, input models.CommitInput) (*models.CommitPayload, error)
461 Rollback(ctx context.Context, input models.RollbackInput) (*models.RollbackPayload, error)
462}
463type QueryResolver interface {
464 Repository(ctx context.Context, ref *string) (*models.Repository, error)
465}
466type RepositoryResolver interface {
467 Name(ctx context.Context, obj *models.Repository) (*string, error)
468 AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
469 Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
470 AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
471 Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
472 UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
473 ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
474}
475type SetStatusOperationResolver interface {
476 ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
477 Author(ctx context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error)
478 Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
479 Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
480}
481type SetStatusTimelineItemResolver interface {
482 ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
483 Author(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error)
484 Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
485 Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
486}
487type SetTitleOperationResolver interface {
488 ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
489 Author(ctx context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error)
490 Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
491}
492type SetTitleTimelineItemResolver interface {
493 ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
494 Author(ctx context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error)
495 Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
496}
497
498type executableSchema struct {
499 resolvers ResolverRoot
500 directives DirectiveRoot
501 complexity ComplexityRoot
502}
503
504func (e *executableSchema) Schema() *ast.Schema {
505 return parsedSchema
506}
507
508func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
509 ec := executionContext{nil, e}
510 _ = ec
511 switch typeName + "." + field {
512
513 case "AddCommentOperation.author":
514 if e.complexity.AddCommentOperation.Author == nil {
515 break
516 }
517
518 return e.complexity.AddCommentOperation.Author(childComplexity), true
519
520 case "AddCommentOperation.date":
521 if e.complexity.AddCommentOperation.Date == nil {
522 break
523 }
524
525 return e.complexity.AddCommentOperation.Date(childComplexity), true
526
527 case "AddCommentOperation.files":
528 if e.complexity.AddCommentOperation.Files == nil {
529 break
530 }
531
532 return e.complexity.AddCommentOperation.Files(childComplexity), true
533
534 case "AddCommentOperation.id":
535 if e.complexity.AddCommentOperation.ID == nil {
536 break
537 }
538
539 return e.complexity.AddCommentOperation.ID(childComplexity), true
540
541 case "AddCommentOperation.message":
542 if e.complexity.AddCommentOperation.Message == nil {
543 break
544 }
545
546 return e.complexity.AddCommentOperation.Message(childComplexity), true
547
548 case "AddCommentPayload.bug":
549 if e.complexity.AddCommentPayload.Bug == nil {
550 break
551 }
552
553 return e.complexity.AddCommentPayload.Bug(childComplexity), true
554
555 case "AddCommentPayload.clientMutationId":
556 if e.complexity.AddCommentPayload.ClientMutationID == nil {
557 break
558 }
559
560 return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
561
562 case "AddCommentPayload.operation":
563 if e.complexity.AddCommentPayload.Operation == nil {
564 break
565 }
566
567 return e.complexity.AddCommentPayload.Operation(childComplexity), true
568
569 case "AddCommentTimelineItem.author":
570 if e.complexity.AddCommentTimelineItem.Author == nil {
571 break
572 }
573
574 return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
575
576 case "AddCommentTimelineItem.createdAt":
577 if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
578 break
579 }
580
581 return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
582
583 case "AddCommentTimelineItem.edited":
584 if e.complexity.AddCommentTimelineItem.Edited == nil {
585 break
586 }
587
588 return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
589
590 case "AddCommentTimelineItem.files":
591 if e.complexity.AddCommentTimelineItem.Files == nil {
592 break
593 }
594
595 return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
596
597 case "AddCommentTimelineItem.history":
598 if e.complexity.AddCommentTimelineItem.History == nil {
599 break
600 }
601
602 return e.complexity.AddCommentTimelineItem.History(childComplexity), true
603
604 case "AddCommentTimelineItem.id":
605 if e.complexity.AddCommentTimelineItem.ID == nil {
606 break
607 }
608
609 return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
610
611 case "AddCommentTimelineItem.lastEdit":
612 if e.complexity.AddCommentTimelineItem.LastEdit == nil {
613 break
614 }
615
616 return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
617
618 case "AddCommentTimelineItem.message":
619 if e.complexity.AddCommentTimelineItem.Message == nil {
620 break
621 }
622
623 return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
624
625 case "AddCommentTimelineItem.messageIsEmpty":
626 if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
627 break
628 }
629
630 return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
631
632 case "Bug.actors":
633 if e.complexity.Bug.Actors == nil {
634 break
635 }
636
637 args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
638 if err != nil {
639 return 0, false
640 }
641
642 return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
643
644 case "Bug.author":
645 if e.complexity.Bug.Author == nil {
646 break
647 }
648
649 return e.complexity.Bug.Author(childComplexity), true
650
651 case "Bug.comments":
652 if e.complexity.Bug.Comments == nil {
653 break
654 }
655
656 args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
657 if err != nil {
658 return 0, false
659 }
660
661 return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
662
663 case "Bug.createdAt":
664 if e.complexity.Bug.CreatedAt == nil {
665 break
666 }
667
668 return e.complexity.Bug.CreatedAt(childComplexity), true
669
670 case "Bug.humanId":
671 if e.complexity.Bug.HumanID == nil {
672 break
673 }
674
675 return e.complexity.Bug.HumanID(childComplexity), true
676
677 case "Bug.id":
678 if e.complexity.Bug.ID == nil {
679 break
680 }
681
682 return e.complexity.Bug.ID(childComplexity), true
683
684 case "Bug.labels":
685 if e.complexity.Bug.Labels == nil {
686 break
687 }
688
689 return e.complexity.Bug.Labels(childComplexity), true
690
691 case "Bug.lastEdit":
692 if e.complexity.Bug.LastEdit == nil {
693 break
694 }
695
696 return e.complexity.Bug.LastEdit(childComplexity), true
697
698 case "Bug.operations":
699 if e.complexity.Bug.Operations == nil {
700 break
701 }
702
703 args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
704 if err != nil {
705 return 0, false
706 }
707
708 return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
709
710 case "Bug.participants":
711 if e.complexity.Bug.Participants == nil {
712 break
713 }
714
715 args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
716 if err != nil {
717 return 0, false
718 }
719
720 return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
721
722 case "Bug.status":
723 if e.complexity.Bug.Status == nil {
724 break
725 }
726
727 return e.complexity.Bug.Status(childComplexity), true
728
729 case "Bug.timeline":
730 if e.complexity.Bug.Timeline == nil {
731 break
732 }
733
734 args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
735 if err != nil {
736 return 0, false
737 }
738
739 return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
740
741 case "Bug.title":
742 if e.complexity.Bug.Title == nil {
743 break
744 }
745
746 return e.complexity.Bug.Title(childComplexity), true
747
748 case "BugConnection.edges":
749 if e.complexity.BugConnection.Edges == nil {
750 break
751 }
752
753 return e.complexity.BugConnection.Edges(childComplexity), true
754
755 case "BugConnection.nodes":
756 if e.complexity.BugConnection.Nodes == nil {
757 break
758 }
759
760 return e.complexity.BugConnection.Nodes(childComplexity), true
761
762 case "BugConnection.pageInfo":
763 if e.complexity.BugConnection.PageInfo == nil {
764 break
765 }
766
767 return e.complexity.BugConnection.PageInfo(childComplexity), true
768
769 case "BugConnection.totalCount":
770 if e.complexity.BugConnection.TotalCount == nil {
771 break
772 }
773
774 return e.complexity.BugConnection.TotalCount(childComplexity), true
775
776 case "BugEdge.cursor":
777 if e.complexity.BugEdge.Cursor == nil {
778 break
779 }
780
781 return e.complexity.BugEdge.Cursor(childComplexity), true
782
783 case "BugEdge.node":
784 if e.complexity.BugEdge.Node == nil {
785 break
786 }
787
788 return e.complexity.BugEdge.Node(childComplexity), true
789
790 case "ChangeLabelPayload.bug":
791 if e.complexity.ChangeLabelPayload.Bug == nil {
792 break
793 }
794
795 return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
796
797 case "ChangeLabelPayload.clientMutationId":
798 if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
799 break
800 }
801
802 return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
803
804 case "ChangeLabelPayload.operation":
805 if e.complexity.ChangeLabelPayload.Operation == nil {
806 break
807 }
808
809 return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
810
811 case "ChangeLabelPayload.results":
812 if e.complexity.ChangeLabelPayload.Results == nil {
813 break
814 }
815
816 return e.complexity.ChangeLabelPayload.Results(childComplexity), true
817
818 case "CloseBugPayload.bug":
819 if e.complexity.CloseBugPayload.Bug == nil {
820 break
821 }
822
823 return e.complexity.CloseBugPayload.Bug(childComplexity), true
824
825 case "CloseBugPayload.clientMutationId":
826 if e.complexity.CloseBugPayload.ClientMutationID == nil {
827 break
828 }
829
830 return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
831
832 case "CloseBugPayload.operation":
833 if e.complexity.CloseBugPayload.Operation == nil {
834 break
835 }
836
837 return e.complexity.CloseBugPayload.Operation(childComplexity), true
838
839 case "Color.B":
840 if e.complexity.Color.B == nil {
841 break
842 }
843
844 return e.complexity.Color.B(childComplexity), true
845
846 case "Color.G":
847 if e.complexity.Color.G == nil {
848 break
849 }
850
851 return e.complexity.Color.G(childComplexity), true
852
853 case "Color.R":
854 if e.complexity.Color.R == nil {
855 break
856 }
857
858 return e.complexity.Color.R(childComplexity), true
859
860 case "Comment.author":
861 if e.complexity.Comment.Author == nil {
862 break
863 }
864
865 return e.complexity.Comment.Author(childComplexity), true
866
867 case "Comment.files":
868 if e.complexity.Comment.Files == nil {
869 break
870 }
871
872 return e.complexity.Comment.Files(childComplexity), true
873
874 case "Comment.message":
875 if e.complexity.Comment.Message == nil {
876 break
877 }
878
879 return e.complexity.Comment.Message(childComplexity), true
880
881 case "CommentConnection.edges":
882 if e.complexity.CommentConnection.Edges == nil {
883 break
884 }
885
886 return e.complexity.CommentConnection.Edges(childComplexity), true
887
888 case "CommentConnection.nodes":
889 if e.complexity.CommentConnection.Nodes == nil {
890 break
891 }
892
893 return e.complexity.CommentConnection.Nodes(childComplexity), true
894
895 case "CommentConnection.pageInfo":
896 if e.complexity.CommentConnection.PageInfo == nil {
897 break
898 }
899
900 return e.complexity.CommentConnection.PageInfo(childComplexity), true
901
902 case "CommentConnection.totalCount":
903 if e.complexity.CommentConnection.TotalCount == nil {
904 break
905 }
906
907 return e.complexity.CommentConnection.TotalCount(childComplexity), true
908
909 case "CommentEdge.cursor":
910 if e.complexity.CommentEdge.Cursor == nil {
911 break
912 }
913
914 return e.complexity.CommentEdge.Cursor(childComplexity), true
915
916 case "CommentEdge.node":
917 if e.complexity.CommentEdge.Node == nil {
918 break
919 }
920
921 return e.complexity.CommentEdge.Node(childComplexity), true
922
923 case "CommentHistoryStep.date":
924 if e.complexity.CommentHistoryStep.Date == nil {
925 break
926 }
927
928 return e.complexity.CommentHistoryStep.Date(childComplexity), true
929
930 case "CommentHistoryStep.message":
931 if e.complexity.CommentHistoryStep.Message == nil {
932 break
933 }
934
935 return e.complexity.CommentHistoryStep.Message(childComplexity), true
936
937 case "CommitPayload.bug":
938 if e.complexity.CommitPayload.Bug == nil {
939 break
940 }
941
942 return e.complexity.CommitPayload.Bug(childComplexity), true
943
944 case "CommitPayload.clientMutationId":
945 if e.complexity.CommitPayload.ClientMutationID == nil {
946 break
947 }
948
949 return e.complexity.CommitPayload.ClientMutationID(childComplexity), true
950
951 case "CommitPayload.id":
952 if e.complexity.CommitPayload.ID == nil {
953 break
954 }
955
956 return e.complexity.CommitPayload.ID(childComplexity), true
957
958 case "CreateOperation.author":
959 if e.complexity.CreateOperation.Author == nil {
960 break
961 }
962
963 return e.complexity.CreateOperation.Author(childComplexity), true
964
965 case "CreateOperation.date":
966 if e.complexity.CreateOperation.Date == nil {
967 break
968 }
969
970 return e.complexity.CreateOperation.Date(childComplexity), true
971
972 case "CreateOperation.files":
973 if e.complexity.CreateOperation.Files == nil {
974 break
975 }
976
977 return e.complexity.CreateOperation.Files(childComplexity), true
978
979 case "CreateOperation.id":
980 if e.complexity.CreateOperation.ID == nil {
981 break
982 }
983
984 return e.complexity.CreateOperation.ID(childComplexity), true
985
986 case "CreateOperation.message":
987 if e.complexity.CreateOperation.Message == nil {
988 break
989 }
990
991 return e.complexity.CreateOperation.Message(childComplexity), true
992
993 case "CreateOperation.title":
994 if e.complexity.CreateOperation.Title == nil {
995 break
996 }
997
998 return e.complexity.CreateOperation.Title(childComplexity), true
999
1000 case "CreateTimelineItem.author":
1001 if e.complexity.CreateTimelineItem.Author == nil {
1002 break
1003 }
1004
1005 return e.complexity.CreateTimelineItem.Author(childComplexity), true
1006
1007 case "CreateTimelineItem.createdAt":
1008 if e.complexity.CreateTimelineItem.CreatedAt == nil {
1009 break
1010 }
1011
1012 return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
1013
1014 case "CreateTimelineItem.edited":
1015 if e.complexity.CreateTimelineItem.Edited == nil {
1016 break
1017 }
1018
1019 return e.complexity.CreateTimelineItem.Edited(childComplexity), true
1020
1021 case "CreateTimelineItem.files":
1022 if e.complexity.CreateTimelineItem.Files == nil {
1023 break
1024 }
1025
1026 return e.complexity.CreateTimelineItem.Files(childComplexity), true
1027
1028 case "CreateTimelineItem.history":
1029 if e.complexity.CreateTimelineItem.History == nil {
1030 break
1031 }
1032
1033 return e.complexity.CreateTimelineItem.History(childComplexity), true
1034
1035 case "CreateTimelineItem.id":
1036 if e.complexity.CreateTimelineItem.ID == nil {
1037 break
1038 }
1039
1040 return e.complexity.CreateTimelineItem.ID(childComplexity), true
1041
1042 case "CreateTimelineItem.lastEdit":
1043 if e.complexity.CreateTimelineItem.LastEdit == nil {
1044 break
1045 }
1046
1047 return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
1048
1049 case "CreateTimelineItem.message":
1050 if e.complexity.CreateTimelineItem.Message == nil {
1051 break
1052 }
1053
1054 return e.complexity.CreateTimelineItem.Message(childComplexity), true
1055
1056 case "CreateTimelineItem.messageIsEmpty":
1057 if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
1058 break
1059 }
1060
1061 return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
1062
1063 case "EditCommentOperation.author":
1064 if e.complexity.EditCommentOperation.Author == nil {
1065 break
1066 }
1067
1068 return e.complexity.EditCommentOperation.Author(childComplexity), true
1069
1070 case "EditCommentOperation.date":
1071 if e.complexity.EditCommentOperation.Date == nil {
1072 break
1073 }
1074
1075 return e.complexity.EditCommentOperation.Date(childComplexity), true
1076
1077 case "EditCommentOperation.files":
1078 if e.complexity.EditCommentOperation.Files == nil {
1079 break
1080 }
1081
1082 return e.complexity.EditCommentOperation.Files(childComplexity), true
1083
1084 case "EditCommentOperation.id":
1085 if e.complexity.EditCommentOperation.ID == nil {
1086 break
1087 }
1088
1089 return e.complexity.EditCommentOperation.ID(childComplexity), true
1090
1091 case "EditCommentOperation.message":
1092 if e.complexity.EditCommentOperation.Message == nil {
1093 break
1094 }
1095
1096 return e.complexity.EditCommentOperation.Message(childComplexity), true
1097
1098 case "EditCommentOperation.target":
1099 if e.complexity.EditCommentOperation.Target == nil {
1100 break
1101 }
1102
1103 return e.complexity.EditCommentOperation.Target(childComplexity), true
1104
1105 case "Identity.avatarUrl":
1106 if e.complexity.Identity.AvatarUrl == nil {
1107 break
1108 }
1109
1110 return e.complexity.Identity.AvatarUrl(childComplexity), true
1111
1112 case "Identity.displayName":
1113 if e.complexity.Identity.DisplayName == nil {
1114 break
1115 }
1116
1117 return e.complexity.Identity.DisplayName(childComplexity), true
1118
1119 case "Identity.email":
1120 if e.complexity.Identity.Email == nil {
1121 break
1122 }
1123
1124 return e.complexity.Identity.Email(childComplexity), true
1125
1126 case "Identity.humanId":
1127 if e.complexity.Identity.HumanID == nil {
1128 break
1129 }
1130
1131 return e.complexity.Identity.HumanID(childComplexity), true
1132
1133 case "Identity.id":
1134 if e.complexity.Identity.ID == nil {
1135 break
1136 }
1137
1138 return e.complexity.Identity.ID(childComplexity), true
1139
1140 case "Identity.isProtected":
1141 if e.complexity.Identity.IsProtected == nil {
1142 break
1143 }
1144
1145 return e.complexity.Identity.IsProtected(childComplexity), true
1146
1147 case "Identity.name":
1148 if e.complexity.Identity.Name == nil {
1149 break
1150 }
1151
1152 return e.complexity.Identity.Name(childComplexity), true
1153
1154 case "IdentityConnection.edges":
1155 if e.complexity.IdentityConnection.Edges == nil {
1156 break
1157 }
1158
1159 return e.complexity.IdentityConnection.Edges(childComplexity), true
1160
1161 case "IdentityConnection.nodes":
1162 if e.complexity.IdentityConnection.Nodes == nil {
1163 break
1164 }
1165
1166 return e.complexity.IdentityConnection.Nodes(childComplexity), true
1167
1168 case "IdentityConnection.pageInfo":
1169 if e.complexity.IdentityConnection.PageInfo == nil {
1170 break
1171 }
1172
1173 return e.complexity.IdentityConnection.PageInfo(childComplexity), true
1174
1175 case "IdentityConnection.totalCount":
1176 if e.complexity.IdentityConnection.TotalCount == nil {
1177 break
1178 }
1179
1180 return e.complexity.IdentityConnection.TotalCount(childComplexity), true
1181
1182 case "IdentityEdge.cursor":
1183 if e.complexity.IdentityEdge.Cursor == nil {
1184 break
1185 }
1186
1187 return e.complexity.IdentityEdge.Cursor(childComplexity), true
1188
1189 case "IdentityEdge.node":
1190 if e.complexity.IdentityEdge.Node == nil {
1191 break
1192 }
1193
1194 return e.complexity.IdentityEdge.Node(childComplexity), true
1195
1196 case "Label.color":
1197 if e.complexity.Label.Color == nil {
1198 break
1199 }
1200
1201 return e.complexity.Label.Color(childComplexity), true
1202
1203 case "Label.name":
1204 if e.complexity.Label.Name == nil {
1205 break
1206 }
1207
1208 return e.complexity.Label.Name(childComplexity), true
1209
1210 case "LabelChangeOperation.added":
1211 if e.complexity.LabelChangeOperation.Added == nil {
1212 break
1213 }
1214
1215 return e.complexity.LabelChangeOperation.Added(childComplexity), true
1216
1217 case "LabelChangeOperation.author":
1218 if e.complexity.LabelChangeOperation.Author == nil {
1219 break
1220 }
1221
1222 return e.complexity.LabelChangeOperation.Author(childComplexity), true
1223
1224 case "LabelChangeOperation.date":
1225 if e.complexity.LabelChangeOperation.Date == nil {
1226 break
1227 }
1228
1229 return e.complexity.LabelChangeOperation.Date(childComplexity), true
1230
1231 case "LabelChangeOperation.id":
1232 if e.complexity.LabelChangeOperation.ID == nil {
1233 break
1234 }
1235
1236 return e.complexity.LabelChangeOperation.ID(childComplexity), true
1237
1238 case "LabelChangeOperation.removed":
1239 if e.complexity.LabelChangeOperation.Removed == nil {
1240 break
1241 }
1242
1243 return e.complexity.LabelChangeOperation.Removed(childComplexity), true
1244
1245 case "LabelChangeResult.label":
1246 if e.complexity.LabelChangeResult.Label == nil {
1247 break
1248 }
1249
1250 return e.complexity.LabelChangeResult.Label(childComplexity), true
1251
1252 case "LabelChangeResult.status":
1253 if e.complexity.LabelChangeResult.Status == nil {
1254 break
1255 }
1256
1257 return e.complexity.LabelChangeResult.Status(childComplexity), true
1258
1259 case "LabelChangeTimelineItem.added":
1260 if e.complexity.LabelChangeTimelineItem.Added == nil {
1261 break
1262 }
1263
1264 return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
1265
1266 case "LabelChangeTimelineItem.author":
1267 if e.complexity.LabelChangeTimelineItem.Author == nil {
1268 break
1269 }
1270
1271 return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
1272
1273 case "LabelChangeTimelineItem.date":
1274 if e.complexity.LabelChangeTimelineItem.Date == nil {
1275 break
1276 }
1277
1278 return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
1279
1280 case "LabelChangeTimelineItem.id":
1281 if e.complexity.LabelChangeTimelineItem.ID == nil {
1282 break
1283 }
1284
1285 return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
1286
1287 case "LabelChangeTimelineItem.removed":
1288 if e.complexity.LabelChangeTimelineItem.Removed == nil {
1289 break
1290 }
1291
1292 return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
1293
1294 case "LabelConnection.edges":
1295 if e.complexity.LabelConnection.Edges == nil {
1296 break
1297 }
1298
1299 return e.complexity.LabelConnection.Edges(childComplexity), true
1300
1301 case "LabelConnection.nodes":
1302 if e.complexity.LabelConnection.Nodes == nil {
1303 break
1304 }
1305
1306 return e.complexity.LabelConnection.Nodes(childComplexity), true
1307
1308 case "LabelConnection.pageInfo":
1309 if e.complexity.LabelConnection.PageInfo == nil {
1310 break
1311 }
1312
1313 return e.complexity.LabelConnection.PageInfo(childComplexity), true
1314
1315 case "LabelConnection.totalCount":
1316 if e.complexity.LabelConnection.TotalCount == nil {
1317 break
1318 }
1319
1320 return e.complexity.LabelConnection.TotalCount(childComplexity), true
1321
1322 case "LabelEdge.cursor":
1323 if e.complexity.LabelEdge.Cursor == nil {
1324 break
1325 }
1326
1327 return e.complexity.LabelEdge.Cursor(childComplexity), true
1328
1329 case "LabelEdge.node":
1330 if e.complexity.LabelEdge.Node == nil {
1331 break
1332 }
1333
1334 return e.complexity.LabelEdge.Node(childComplexity), true
1335
1336 case "Mutation.addComment":
1337 if e.complexity.Mutation.AddComment == nil {
1338 break
1339 }
1340
1341 args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
1342 if err != nil {
1343 return 0, false
1344 }
1345
1346 return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput), args["txId"].(*string)), true
1347
1348 case "Mutation.changeLabels":
1349 if e.complexity.Mutation.ChangeLabels == nil {
1350 break
1351 }
1352
1353 args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
1354 if err != nil {
1355 return 0, false
1356 }
1357
1358 return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(models.ChangeLabelInput), args["txId"].(*string)), true
1359
1360 case "Mutation.closeBug":
1361 if e.complexity.Mutation.CloseBug == nil {
1362 break
1363 }
1364
1365 args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
1366 if err != nil {
1367 return 0, false
1368 }
1369
1370 return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput), args["txId"].(*string)), true
1371
1372 case "Mutation.commit":
1373 if e.complexity.Mutation.Commit == nil {
1374 break
1375 }
1376
1377 args, err := ec.field_Mutation_commit_args(context.TODO(), rawArgs)
1378 if err != nil {
1379 return 0, false
1380 }
1381
1382 return e.complexity.Mutation.Commit(childComplexity, args["input"].(models.CommitInput)), true
1383
1384 case "Mutation.newBug":
1385 if e.complexity.Mutation.NewBug == nil {
1386 break
1387 }
1388
1389 args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
1390 if err != nil {
1391 return 0, false
1392 }
1393
1394 return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput), args["txId"].(*string)), true
1395
1396 case "Mutation.openBug":
1397 if e.complexity.Mutation.OpenBug == nil {
1398 break
1399 }
1400
1401 args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
1402 if err != nil {
1403 return 0, false
1404 }
1405
1406 return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput), args["txId"].(*string)), true
1407
1408 case "Mutation.rollback":
1409 if e.complexity.Mutation.Rollback == nil {
1410 break
1411 }
1412
1413 args, err := ec.field_Mutation_rollback_args(context.TODO(), rawArgs)
1414 if err != nil {
1415 return 0, false
1416 }
1417
1418 return e.complexity.Mutation.Rollback(childComplexity, args["input"].(models.RollbackInput)), true
1419
1420 case "Mutation.setTitle":
1421 if e.complexity.Mutation.SetTitle == nil {
1422 break
1423 }
1424
1425 args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
1426 if err != nil {
1427 return 0, false
1428 }
1429
1430 return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput), args["txId"].(*string)), true
1431
1432 case "Mutation.startTransaction":
1433 if e.complexity.Mutation.StartTransaction == nil {
1434 break
1435 }
1436
1437 args, err := ec.field_Mutation_startTransaction_args(context.TODO(), rawArgs)
1438 if err != nil {
1439 return 0, false
1440 }
1441
1442 return e.complexity.Mutation.StartTransaction(childComplexity, args["input"].(models.StartTransactionInput)), true
1443
1444 case "NewBugPayload.bug":
1445 if e.complexity.NewBugPayload.Bug == nil {
1446 break
1447 }
1448
1449 return e.complexity.NewBugPayload.Bug(childComplexity), true
1450
1451 case "NewBugPayload.clientMutationId":
1452 if e.complexity.NewBugPayload.ClientMutationID == nil {
1453 break
1454 }
1455
1456 return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
1457
1458 case "NewBugPayload.operation":
1459 if e.complexity.NewBugPayload.Operation == nil {
1460 break
1461 }
1462
1463 return e.complexity.NewBugPayload.Operation(childComplexity), true
1464
1465 case "OpenBugPayload.bug":
1466 if e.complexity.OpenBugPayload.Bug == nil {
1467 break
1468 }
1469
1470 return e.complexity.OpenBugPayload.Bug(childComplexity), true
1471
1472 case "OpenBugPayload.clientMutationId":
1473 if e.complexity.OpenBugPayload.ClientMutationID == nil {
1474 break
1475 }
1476
1477 return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
1478
1479 case "OpenBugPayload.operation":
1480 if e.complexity.OpenBugPayload.Operation == nil {
1481 break
1482 }
1483
1484 return e.complexity.OpenBugPayload.Operation(childComplexity), true
1485
1486 case "OperationConnection.edges":
1487 if e.complexity.OperationConnection.Edges == nil {
1488 break
1489 }
1490
1491 return e.complexity.OperationConnection.Edges(childComplexity), true
1492
1493 case "OperationConnection.nodes":
1494 if e.complexity.OperationConnection.Nodes == nil {
1495 break
1496 }
1497
1498 return e.complexity.OperationConnection.Nodes(childComplexity), true
1499
1500 case "OperationConnection.pageInfo":
1501 if e.complexity.OperationConnection.PageInfo == nil {
1502 break
1503 }
1504
1505 return e.complexity.OperationConnection.PageInfo(childComplexity), true
1506
1507 case "OperationConnection.totalCount":
1508 if e.complexity.OperationConnection.TotalCount == nil {
1509 break
1510 }
1511
1512 return e.complexity.OperationConnection.TotalCount(childComplexity), true
1513
1514 case "OperationEdge.cursor":
1515 if e.complexity.OperationEdge.Cursor == nil {
1516 break
1517 }
1518
1519 return e.complexity.OperationEdge.Cursor(childComplexity), true
1520
1521 case "OperationEdge.node":
1522 if e.complexity.OperationEdge.Node == nil {
1523 break
1524 }
1525
1526 return e.complexity.OperationEdge.Node(childComplexity), true
1527
1528 case "PageInfo.endCursor":
1529 if e.complexity.PageInfo.EndCursor == nil {
1530 break
1531 }
1532
1533 return e.complexity.PageInfo.EndCursor(childComplexity), true
1534
1535 case "PageInfo.hasNextPage":
1536 if e.complexity.PageInfo.HasNextPage == nil {
1537 break
1538 }
1539
1540 return e.complexity.PageInfo.HasNextPage(childComplexity), true
1541
1542 case "PageInfo.hasPreviousPage":
1543 if e.complexity.PageInfo.HasPreviousPage == nil {
1544 break
1545 }
1546
1547 return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
1548
1549 case "PageInfo.startCursor":
1550 if e.complexity.PageInfo.StartCursor == nil {
1551 break
1552 }
1553
1554 return e.complexity.PageInfo.StartCursor(childComplexity), true
1555
1556 case "Query.repository":
1557 if e.complexity.Query.Repository == nil {
1558 break
1559 }
1560
1561 args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
1562 if err != nil {
1563 return 0, false
1564 }
1565
1566 return e.complexity.Query.Repository(childComplexity, args["ref"].(*string)), true
1567
1568 case "Repository.allBugs":
1569 if e.complexity.Repository.AllBugs == nil {
1570 break
1571 }
1572
1573 args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
1574 if err != nil {
1575 return 0, false
1576 }
1577
1578 return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
1579
1580 case "Repository.allIdentities":
1581 if e.complexity.Repository.AllIdentities == nil {
1582 break
1583 }
1584
1585 args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
1586 if err != nil {
1587 return 0, false
1588 }
1589
1590 return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1591
1592 case "Repository.bug":
1593 if e.complexity.Repository.Bug == nil {
1594 break
1595 }
1596
1597 args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
1598 if err != nil {
1599 return 0, false
1600 }
1601
1602 return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
1603
1604 case "Repository.identity":
1605 if e.complexity.Repository.Identity == nil {
1606 break
1607 }
1608
1609 args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
1610 if err != nil {
1611 return 0, false
1612 }
1613
1614 return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
1615
1616 case "Repository.name":
1617 if e.complexity.Repository.Name == nil {
1618 break
1619 }
1620
1621 return e.complexity.Repository.Name(childComplexity), true
1622
1623 case "Repository.userIdentity":
1624 if e.complexity.Repository.UserIdentity == nil {
1625 break
1626 }
1627
1628 return e.complexity.Repository.UserIdentity(childComplexity), true
1629
1630 case "Repository.validLabels":
1631 if e.complexity.Repository.ValidLabels == nil {
1632 break
1633 }
1634
1635 args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
1636 if err != nil {
1637 return 0, false
1638 }
1639
1640 return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1641
1642 case "RollbackPayload.bug":
1643 if e.complexity.RollbackPayload.Bug == nil {
1644 break
1645 }
1646
1647 return e.complexity.RollbackPayload.Bug(childComplexity), true
1648
1649 case "RollbackPayload.clientMutationId":
1650 if e.complexity.RollbackPayload.ClientMutationID == nil {
1651 break
1652 }
1653
1654 return e.complexity.RollbackPayload.ClientMutationID(childComplexity), true
1655
1656 case "RollbackPayload.id":
1657 if e.complexity.RollbackPayload.ID == nil {
1658 break
1659 }
1660
1661 return e.complexity.RollbackPayload.ID(childComplexity), true
1662
1663 case "SetStatusOperation.author":
1664 if e.complexity.SetStatusOperation.Author == nil {
1665 break
1666 }
1667
1668 return e.complexity.SetStatusOperation.Author(childComplexity), true
1669
1670 case "SetStatusOperation.date":
1671 if e.complexity.SetStatusOperation.Date == nil {
1672 break
1673 }
1674
1675 return e.complexity.SetStatusOperation.Date(childComplexity), true
1676
1677 case "SetStatusOperation.id":
1678 if e.complexity.SetStatusOperation.ID == nil {
1679 break
1680 }
1681
1682 return e.complexity.SetStatusOperation.ID(childComplexity), true
1683
1684 case "SetStatusOperation.status":
1685 if e.complexity.SetStatusOperation.Status == nil {
1686 break
1687 }
1688
1689 return e.complexity.SetStatusOperation.Status(childComplexity), true
1690
1691 case "SetStatusTimelineItem.author":
1692 if e.complexity.SetStatusTimelineItem.Author == nil {
1693 break
1694 }
1695
1696 return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
1697
1698 case "SetStatusTimelineItem.date":
1699 if e.complexity.SetStatusTimelineItem.Date == nil {
1700 break
1701 }
1702
1703 return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
1704
1705 case "SetStatusTimelineItem.id":
1706 if e.complexity.SetStatusTimelineItem.ID == nil {
1707 break
1708 }
1709
1710 return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
1711
1712 case "SetStatusTimelineItem.status":
1713 if e.complexity.SetStatusTimelineItem.Status == nil {
1714 break
1715 }
1716
1717 return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
1718
1719 case "SetTitleOperation.author":
1720 if e.complexity.SetTitleOperation.Author == nil {
1721 break
1722 }
1723
1724 return e.complexity.SetTitleOperation.Author(childComplexity), true
1725
1726 case "SetTitleOperation.date":
1727 if e.complexity.SetTitleOperation.Date == nil {
1728 break
1729 }
1730
1731 return e.complexity.SetTitleOperation.Date(childComplexity), true
1732
1733 case "SetTitleOperation.id":
1734 if e.complexity.SetTitleOperation.ID == nil {
1735 break
1736 }
1737
1738 return e.complexity.SetTitleOperation.ID(childComplexity), true
1739
1740 case "SetTitleOperation.title":
1741 if e.complexity.SetTitleOperation.Title == nil {
1742 break
1743 }
1744
1745 return e.complexity.SetTitleOperation.Title(childComplexity), true
1746
1747 case "SetTitleOperation.was":
1748 if e.complexity.SetTitleOperation.Was == nil {
1749 break
1750 }
1751
1752 return e.complexity.SetTitleOperation.Was(childComplexity), true
1753
1754 case "SetTitlePayload.bug":
1755 if e.complexity.SetTitlePayload.Bug == nil {
1756 break
1757 }
1758
1759 return e.complexity.SetTitlePayload.Bug(childComplexity), true
1760
1761 case "SetTitlePayload.clientMutationId":
1762 if e.complexity.SetTitlePayload.ClientMutationID == nil {
1763 break
1764 }
1765
1766 return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
1767
1768 case "SetTitlePayload.operation":
1769 if e.complexity.SetTitlePayload.Operation == nil {
1770 break
1771 }
1772
1773 return e.complexity.SetTitlePayload.Operation(childComplexity), true
1774
1775 case "SetTitleTimelineItem.author":
1776 if e.complexity.SetTitleTimelineItem.Author == nil {
1777 break
1778 }
1779
1780 return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
1781
1782 case "SetTitleTimelineItem.date":
1783 if e.complexity.SetTitleTimelineItem.Date == nil {
1784 break
1785 }
1786
1787 return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
1788
1789 case "SetTitleTimelineItem.id":
1790 if e.complexity.SetTitleTimelineItem.ID == nil {
1791 break
1792 }
1793
1794 return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
1795
1796 case "SetTitleTimelineItem.title":
1797 if e.complexity.SetTitleTimelineItem.Title == nil {
1798 break
1799 }
1800
1801 return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
1802
1803 case "SetTitleTimelineItem.was":
1804 if e.complexity.SetTitleTimelineItem.Was == nil {
1805 break
1806 }
1807
1808 return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
1809
1810 case "StartTransactionPayload.clientMutationId":
1811 if e.complexity.StartTransactionPayload.ClientMutationID == nil {
1812 break
1813 }
1814
1815 return e.complexity.StartTransactionPayload.ClientMutationID(childComplexity), true
1816
1817 case "StartTransactionPayload.id":
1818 if e.complexity.StartTransactionPayload.ID == nil {
1819 break
1820 }
1821
1822 return e.complexity.StartTransactionPayload.ID(childComplexity), true
1823
1824 case "TimelineItemConnection.edges":
1825 if e.complexity.TimelineItemConnection.Edges == nil {
1826 break
1827 }
1828
1829 return e.complexity.TimelineItemConnection.Edges(childComplexity), true
1830
1831 case "TimelineItemConnection.nodes":
1832 if e.complexity.TimelineItemConnection.Nodes == nil {
1833 break
1834 }
1835
1836 return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
1837
1838 case "TimelineItemConnection.pageInfo":
1839 if e.complexity.TimelineItemConnection.PageInfo == nil {
1840 break
1841 }
1842
1843 return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
1844
1845 case "TimelineItemConnection.totalCount":
1846 if e.complexity.TimelineItemConnection.TotalCount == nil {
1847 break
1848 }
1849
1850 return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
1851
1852 case "TimelineItemEdge.cursor":
1853 if e.complexity.TimelineItemEdge.Cursor == nil {
1854 break
1855 }
1856
1857 return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
1858
1859 case "TimelineItemEdge.node":
1860 if e.complexity.TimelineItemEdge.Node == nil {
1861 break
1862 }
1863
1864 return e.complexity.TimelineItemEdge.Node(childComplexity), true
1865
1866 }
1867 return 0, false
1868}
1869
1870func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
1871 rc := graphql.GetOperationContext(ctx)
1872 ec := executionContext{rc, e}
1873 first := true
1874
1875 switch rc.Operation.Operation {
1876 case ast.Query:
1877 return func(ctx context.Context) *graphql.Response {
1878 if !first {
1879 return nil
1880 }
1881 first = false
1882 data := ec._Query(ctx, rc.Operation.SelectionSet)
1883 var buf bytes.Buffer
1884 data.MarshalGQL(&buf)
1885
1886 return &graphql.Response{
1887 Data: buf.Bytes(),
1888 }
1889 }
1890 case ast.Mutation:
1891 return func(ctx context.Context) *graphql.Response {
1892 if !first {
1893 return nil
1894 }
1895 first = false
1896 data := ec._Mutation(ctx, rc.Operation.SelectionSet)
1897 var buf bytes.Buffer
1898 data.MarshalGQL(&buf)
1899
1900 return &graphql.Response{
1901 Data: buf.Bytes(),
1902 }
1903 }
1904
1905 default:
1906 return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
1907 }
1908}
1909
1910type executionContext struct {
1911 *graphql.OperationContext
1912 *executableSchema
1913}
1914
1915func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
1916 if ec.DisableIntrospection {
1917 return nil, errors.New("introspection disabled")
1918 }
1919 return introspection.WrapSchema(parsedSchema), nil
1920}
1921
1922func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
1923 if ec.DisableIntrospection {
1924 return nil, errors.New("introspection disabled")
1925 }
1926 return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
1927}
1928
1929var sources = []*ast.Source{
1930 &ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
1931type Comment implements Authored {
1932 """The author of this comment."""
1933 author: Identity!
1934
1935 """The message of this comment."""
1936 message: String!
1937
1938 """All media's hash referenced in this comment"""
1939 files: [Hash!]!
1940}
1941
1942type CommentConnection {
1943 edges: [CommentEdge!]!
1944 nodes: [Comment!]!
1945 pageInfo: PageInfo!
1946 totalCount: Int!
1947}
1948
1949type CommentEdge {
1950 cursor: String!
1951 node: Comment!
1952}
1953
1954enum Status {
1955 OPEN
1956 CLOSED
1957}
1958
1959type Bug implements Authored {
1960 """The identifier for this bug"""
1961 id: String!
1962 """The human version (truncated) identifier for this bug"""
1963 humanId: String!
1964 status: Status!
1965 title: String!
1966 labels: [Label!]!
1967 author: Identity!
1968 createdAt: Time!
1969 lastEdit: Time!
1970
1971 """The actors of the bug. Actors are Identity that have interacted with the bug."""
1972 actors(
1973 """Returns the elements in the list that come after the specified cursor."""
1974 after: String
1975 """Returns the elements in the list that come before the specified cursor."""
1976 before: String
1977 """Returns the first _n_ elements from the list."""
1978 first: Int
1979 """Returns the last _n_ elements from the list."""
1980 last: Int
1981 ): IdentityConnection!
1982
1983 """The participants of the bug. Participants are Identity that have created or
1984 added a comment on the bug."""
1985 participants(
1986 """Returns the elements in the list that come after the specified cursor."""
1987 after: String
1988 """Returns the elements in the list that come before the specified cursor."""
1989 before: String
1990 """Returns the first _n_ elements from the list."""
1991 first: Int
1992 """Returns the last _n_ elements from the list."""
1993 last: Int
1994 ): IdentityConnection!
1995
1996 comments(
1997 """Returns the elements in the list that come after the specified cursor."""
1998 after: String
1999 """Returns the elements in the list that come before the specified cursor."""
2000 before: String
2001 """Returns the first _n_ elements from the list."""
2002 first: Int
2003 """Returns the last _n_ elements from the list."""
2004 last: Int
2005 ): CommentConnection!
2006
2007 timeline(
2008 """Returns the elements in the list that come after the specified cursor."""
2009 after: String
2010 """Returns the elements in the list that come before the specified cursor."""
2011 before: String
2012 """Returns the first _n_ elements from the list."""
2013 first: Int
2014 """Returns the last _n_ elements from the list."""
2015 last: Int
2016 ): TimelineItemConnection!
2017
2018 operations(
2019 """Returns the elements in the list that come after the specified cursor."""
2020 after: String
2021 """Returns the elements in the list that come before the specified cursor."""
2022 before: String
2023 """Returns the first _n_ elements from the list."""
2024 first: Int
2025 """Returns the last _n_ elements from the list."""
2026 last: Int
2027 ): OperationConnection!
2028}
2029
2030"""The connection type for Bug."""
2031type BugConnection {
2032 """A list of edges."""
2033 edges: [BugEdge!]!
2034 nodes: [Bug!]!
2035 """Information to aid in pagination."""
2036 pageInfo: PageInfo!
2037 """Identifies the total count of items in the connection."""
2038 totalCount: Int!
2039}
2040
2041"""An edge in a connection."""
2042type BugEdge {
2043 """A cursor for use in pagination."""
2044 cursor: String!
2045 """The item at the end of the edge."""
2046 node: Bug!
2047}
2048`, BuiltIn: false},
2049 &ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
2050type Identity {
2051 """The identifier for this identity"""
2052 id: String!
2053 """The human version (truncated) identifier for this identity"""
2054 humanId: String!
2055 """The name of the person, if known."""
2056 name: String
2057 """The email of the person, if known."""
2058 email: String
2059 """A non-empty string to display, representing the identity, based on the non-empty values."""
2060 displayName: String!
2061 """An url to an avatar"""
2062 avatarUrl: String
2063 """isProtected is true if the chain of git commits started to be signed.
2064 If that's the case, only signed commit with a valid key for this identity can be added."""
2065 isProtected: Boolean!
2066}
2067
2068type IdentityConnection {
2069 edges: [IdentityEdge!]!
2070 nodes: [Identity!]!
2071 pageInfo: PageInfo!
2072 totalCount: Int!
2073}
2074
2075type IdentityEdge {
2076 cursor: String!
2077 node: Identity!
2078}`, BuiltIn: false},
2079 &ast.Source{Name: "schema/label.graphql", Input: `"""Label for a bug."""
2080type Label {
2081 """The name of the label."""
2082 name: String!
2083 """Color of the label."""
2084 color: Color!
2085}
2086
2087type LabelConnection {
2088 edges: [LabelEdge!]!
2089 nodes: [Label!]!
2090 pageInfo: PageInfo!
2091 totalCount: Int!
2092}
2093
2094type LabelEdge {
2095 cursor: String!
2096 node: Label!
2097}`, BuiltIn: false},
2098 &ast.Source{Name: "schema/mutations.graphql", Input: `input NewBugInput {
2099 """A unique identifier for the client performing the mutation."""
2100 clientMutationId: String
2101 """"The name of the repository. If not set, the default repository is used."""
2102 repoRef: String
2103 """The title of the new bug."""
2104 title: String!
2105 """The first message of the new bug."""
2106 message: String!
2107 """The collection of file's hash required for the first message."""
2108 files: [Hash!]
2109}
2110
2111type NewBugPayload {
2112 """A unique identifier for the client performing the mutation."""
2113 clientMutationId: String
2114 """The created bug."""
2115 bug: Bug!
2116 """The resulting operation."""
2117 operation: CreateOperation!
2118}
2119
2120input AddCommentInput {
2121 """A unique identifier for the client performing the mutation."""
2122 clientMutationId: String
2123 """"The name of the repository. If not set, the default repository is used."""
2124 repoRef: String
2125 """The bug ID's prefix."""
2126 prefix: String!
2127 """The first message of the new bug."""
2128 message: String!
2129 """The collection of file's hash required for the first message."""
2130 files: [Hash!]
2131}
2132
2133type AddCommentPayload {
2134 """A unique identifier for the client performing the mutation."""
2135 clientMutationId: String
2136 """The affected bug."""
2137 bug: Bug!
2138 """The resulting operation."""
2139 operation: AddCommentOperation!
2140}
2141
2142input ChangeLabelInput {
2143 """A unique identifier for the client performing the mutation."""
2144 clientMutationId: String
2145 """"The name of the repository. If not set, the default repository is used."""
2146 repoRef: String
2147 """The bug ID's prefix."""
2148 prefix: String!
2149 """The list of label to add."""
2150 added: [String!]
2151 """The list of label to remove."""
2152 Removed: [String!]
2153}
2154
2155enum LabelChangeStatus {
2156 ADDED
2157 REMOVED
2158 DUPLICATE_IN_OP
2159 ALREADY_EXIST
2160 DOESNT_EXIST
2161}
2162
2163type LabelChangeResult {
2164 """The source label."""
2165 label: Label!
2166 """The effect this label had."""
2167 status: LabelChangeStatus!
2168}
2169
2170type ChangeLabelPayload {
2171 """A unique identifier for the client performing the mutation."""
2172 clientMutationId: String
2173 """The affected bug."""
2174 bug: Bug!
2175 """The resulting operation."""
2176 operation: LabelChangeOperation!
2177 """The effect each source label had."""
2178 results: [LabelChangeResult]!
2179}
2180
2181input OpenBugInput {
2182 """A unique identifier for the client performing the mutation."""
2183 clientMutationId: String
2184 """"The name of the repository. If not set, the default repository is used."""
2185 repoRef: String
2186 """The bug ID's prefix."""
2187 prefix: String!
2188}
2189
2190type OpenBugPayload {
2191 """A unique identifier for the client performing the mutation."""
2192 clientMutationId: String
2193 """The affected bug."""
2194 bug: Bug!
2195 """The resulting operation."""
2196 operation: SetStatusOperation!
2197}
2198
2199input CloseBugInput {
2200 """A unique identifier for the client performing the mutation."""
2201 clientMutationId: String
2202 """"The name of the repository. If not set, the default repository is used."""
2203 repoRef: String
2204 """The bug ID's prefix."""
2205 prefix: String!
2206}
2207
2208type CloseBugPayload {
2209 """A unique identifier for the client performing the mutation."""
2210 clientMutationId: String
2211 """The affected bug."""
2212 bug: Bug!
2213 """The resulting operation."""
2214 operation: SetStatusOperation!
2215}
2216
2217input SetTitleInput {
2218 """A unique identifier for the client performing the mutation."""
2219 clientMutationId: String
2220 """"The name of the repository. If not set, the default repository is used."""
2221 repoRef: String
2222 """The bug ID's prefix."""
2223 prefix: String!
2224 """The new title."""
2225 title: String!
2226}
2227
2228type SetTitlePayload {
2229 """A unique identifier for the client performing the mutation."""
2230 clientMutationId: String
2231 """The affected bug."""
2232 bug: Bug!
2233 """The resulting operation"""
2234 operation: SetTitleOperation!
2235}
2236`, BuiltIn: false},
2237 &ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
2238interface Operation {
2239 """The identifier of the operation"""
2240 id: String!
2241 """The operations author."""
2242 author: Identity!
2243 """The datetime when this operation was issued."""
2244 date: Time!
2245}
2246
2247# Connection
2248
2249"""The connection type for an Operation"""
2250type OperationConnection {
2251 edges: [OperationEdge!]!
2252 nodes: [Operation!]!
2253 pageInfo: PageInfo!
2254 totalCount: Int!
2255}
2256
2257"""Represent an Operation"""
2258type OperationEdge {
2259 cursor: String!
2260 node: Operation!
2261}
2262
2263# Operations
2264
2265type CreateOperation implements Operation & Authored {
2266 """The identifier of the operation"""
2267 id: String!
2268 """The author of this object."""
2269 author: Identity!
2270 """The datetime when this operation was issued."""
2271 date: Time!
2272
2273 title: String!
2274 message: String!
2275 files: [Hash!]!
2276}
2277
2278type SetTitleOperation implements Operation & Authored {
2279 """The identifier of the operation"""
2280 id: String!
2281 """The author of this object."""
2282 author: Identity!
2283 """The datetime when this operation was issued."""
2284 date: Time!
2285
2286 title: String!
2287 was: String!
2288}
2289
2290type AddCommentOperation implements Operation & Authored {
2291 """The identifier of the operation"""
2292 id: String!
2293 """The author of this object."""
2294 author: Identity!
2295 """The datetime when this operation was issued."""
2296 date: Time!
2297
2298 message: String!
2299 files: [Hash!]!
2300}
2301
2302type EditCommentOperation implements Operation & Authored {
2303 """The identifier of the operation"""
2304 id: String!
2305 """The author of this object."""
2306 author: Identity!
2307 """The datetime when this operation was issued."""
2308 date: Time!
2309
2310 target: String!
2311 message: String!
2312 files: [Hash!]!
2313}
2314
2315type SetStatusOperation implements Operation & Authored {
2316 """The identifier of the operation"""
2317 id: String!
2318 """The author of this object."""
2319 author: Identity!
2320 """The datetime when this operation was issued."""
2321 date: Time!
2322
2323 status: Status!
2324}
2325
2326type LabelChangeOperation implements Operation & Authored {
2327 """The identifier of the operation"""
2328 id: String!
2329 """The author of this object."""
2330 author: Identity!
2331 """The datetime when this operation was issued."""
2332 date: Time!
2333
2334 added: [Label!]!
2335 removed: [Label!]!
2336}
2337`, BuiltIn: false},
2338 &ast.Source{Name: "schema/repository.graphql", Input: `
2339type Repository {
2340 """The name of the repository"""
2341 name: String
2342
2343 """All the bugs"""
2344 allBugs(
2345 """Returns the elements in the list that come after the specified cursor."""
2346 after: String
2347 """Returns the elements in the list that come before the specified cursor."""
2348 before: String
2349 """Returns the first _n_ elements from the list."""
2350 first: Int
2351 """Returns the last _n_ elements from the list."""
2352 last: Int
2353 """A query to select and order bugs."""
2354 query: String
2355 ): BugConnection!
2356
2357 bug(prefix: String!): Bug
2358
2359 """All the identities"""
2360 allIdentities(
2361 """Returns the elements in the list that come after the specified cursor."""
2362 after: String
2363 """Returns the elements in the list that come before the specified cursor."""
2364 before: String
2365 """Returns the first _n_ elements from the list."""
2366 first: Int
2367 """Returns the last _n_ elements from the list."""
2368 last: Int
2369 ): IdentityConnection!
2370
2371 identity(prefix: String!): Identity
2372
2373 """The identity created or selected by the user as its own"""
2374 userIdentity: Identity
2375
2376 """List of valid labels."""
2377 validLabels(
2378 """Returns the elements in the list that come after the specified cursor."""
2379 after: String
2380 """Returns the elements in the list that come before the specified cursor."""
2381 before: String
2382 """Returns the first _n_ elements from the list."""
2383 first: Int
2384 """Returns the last _n_ elements from the list."""
2385 last: Int
2386 ): LabelConnection!
2387}`, BuiltIn: false},
2388 &ast.Source{Name: "schema/root.graphql", Input: `type Query {
2389 """Access a repository by reference/name. If no ref is given, the default repository is returned if any."""
2390 repository(ref: String): Repository
2391}
2392
2393type Mutation {
2394 """Create a new bug"""
2395 newBug(input: NewBugInput!, txId: TxId): NewBugPayload!
2396 """Add a new comment to a bug"""
2397 addComment(input: AddCommentInput!, txId: TxId): AddCommentPayload!
2398 """Add or remove a set of label on a bug"""
2399 changeLabels(input: ChangeLabelInput!, txId: TxId): ChangeLabelPayload!
2400 """Change a bug's status to open"""
2401 openBug(input: OpenBugInput!, txId: TxId): OpenBugPayload!
2402 """Change a bug's status to closed"""
2403 closeBug(input: CloseBugInput!, txId: TxId): CloseBugPayload!
2404 """Change a bug's title"""
2405 setTitle(input: SetTitleInput!, txId: TxId): SetTitlePayload!
2406
2407 """Start a transaction.
2408 If a transaction ID if passed to the mutation, operation are accumulated
2409 in memory until a commit happen.
2410 """
2411 startTransaction(input: StartTransactionInput!): StartTransactionPayload!
2412 """Commit a transaction. All mutation linked to this transaction are written on disk."""
2413 commit(input: CommitInput!): CommitPayload!
2414 """Rollback a transaction. Alll mutationlinked to this transaction are discarded."""
2415 rollback(input: RollbackInput!): RollbackPayload!
2416}
2417`, BuiltIn: false},
2418 &ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
2419interface TimelineItem {
2420 """The identifier of the source operation"""
2421 id: String!
2422}
2423
2424"""CommentHistoryStep hold one version of a message in the history"""
2425type CommentHistoryStep {
2426 message: String!
2427 date: Time!
2428}
2429
2430# Connection
2431
2432"""The connection type for TimelineItem"""
2433type TimelineItemConnection {
2434 edges: [TimelineItemEdge!]!
2435 nodes: [TimelineItem!]!
2436 pageInfo: PageInfo!
2437 totalCount: Int!
2438}
2439
2440"""Represent a TimelineItem"""
2441type TimelineItemEdge {
2442 cursor: String!
2443 node: TimelineItem!
2444}
2445
2446# Items
2447
2448"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
2449type CreateTimelineItem implements TimelineItem & Authored {
2450 """The identifier of the source operation"""
2451 id: String!
2452 author: Identity!
2453 message: String!
2454 messageIsEmpty: Boolean!
2455 files: [Hash!]!
2456 createdAt: Time!
2457 lastEdit: Time!
2458 edited: Boolean!
2459 history: [CommentHistoryStep!]!
2460}
2461
2462"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
2463type AddCommentTimelineItem implements TimelineItem & Authored {
2464 """The identifier of the source operation"""
2465 id: String!
2466 author: Identity!
2467 message: String!
2468 messageIsEmpty: Boolean!
2469 files: [Hash!]!
2470 createdAt: Time!
2471 lastEdit: Time!
2472 edited: Boolean!
2473 history: [CommentHistoryStep!]!
2474}
2475
2476"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
2477type LabelChangeTimelineItem implements TimelineItem & Authored {
2478 """The identifier of the source operation"""
2479 id: String!
2480 author: Identity!
2481 date: Time!
2482 added: [Label!]!
2483 removed: [Label!]!
2484}
2485
2486"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
2487type SetStatusTimelineItem implements TimelineItem & Authored {
2488 """The identifier of the source operation"""
2489 id: String!
2490 author: Identity!
2491 date: Time!
2492 status: Status!
2493}
2494
2495"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
2496type SetTitleTimelineItem implements TimelineItem & Authored {
2497 """The identifier of the source operation"""
2498 id: String!
2499 author: Identity!
2500 date: Time!
2501 title: String!
2502 was: String!
2503}
2504`, BuiltIn: false},
2505 &ast.Source{Name: "schema/transaction.graphql", Input: `scalar TxId
2506
2507input StartTransactionInput {
2508 """A unique identifier for the client performing the mutation."""
2509 clientMutationId: String
2510 """"The name of the repository. If not set, the default repository is used."""
2511 repoRef: String
2512 """The bug ID's prefix."""
2513 prefix: String!
2514}
2515
2516type StartTransactionPayload {
2517 """A unique identifier for the client performing the mutation."""
2518 clientMutationId: String
2519 """The identifier of the transaction"""
2520 id: TxId!
2521}
2522
2523input CommitInput {
2524 """A unique identifier for the client performing the mutation."""
2525 clientMutationId: String
2526 """The identifier of the transaction"""
2527 id: TxId!
2528}
2529
2530type CommitPayload {
2531 """A unique identifier for the client performing the mutation."""
2532 clientMutationId: String
2533 """The identifier of the transaction"""
2534 id: TxId!
2535 """The affected bug."""
2536 bug: Bug!
2537}
2538
2539input RollbackInput {
2540 """A unique identifier for the client performing the mutation."""
2541 clientMutationId: String
2542 """The identifier of the transaction"""
2543 id: TxId!
2544}
2545
2546type RollbackPayload {
2547 """A unique identifier for the client performing the mutation."""
2548 clientMutationId: String
2549 """The identifier of the transaction"""
2550 id: TxId!
2551 """The affected bug."""
2552 bug: Bug!
2553}`, BuiltIn: false},
2554 &ast.Source{Name: "schema/types.graphql", Input: `scalar Time
2555scalar Hash
2556
2557"""Defines a color by red, green and blue components."""
2558type Color {
2559 """Red component of the color."""
2560 R: Int!
2561 """Green component of the color."""
2562 G: Int!
2563 """Blue component of the color."""
2564 B: Int!
2565}
2566
2567"""Information about pagination in a connection."""
2568type PageInfo {
2569 """When paginating forwards, are there more items?"""
2570 hasNextPage: Boolean!
2571 """When paginating backwards, are there more items?"""
2572 hasPreviousPage: Boolean!
2573 """When paginating backwards, the cursor to continue."""
2574 startCursor: String!
2575 """When paginating forwards, the cursor to continue."""
2576 endCursor: String!
2577}
2578
2579"""An object that has an author."""
2580interface Authored {
2581 """The author of this object."""
2582 author: Identity!
2583}
2584`, BuiltIn: false},
2585}
2586var parsedSchema = gqlparser.MustLoadSchema(sources...)
2587
2588// endregion ************************** generated!.gotpl **************************
2589
2590// region ***************************** args.gotpl *****************************
2591
2592func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2593 var err error
2594 args := map[string]interface{}{}
2595 var arg0 *string
2596 if tmp, ok := rawArgs["after"]; ok {
2597 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2598 if err != nil {
2599 return nil, err
2600 }
2601 }
2602 args["after"] = arg0
2603 var arg1 *string
2604 if tmp, ok := rawArgs["before"]; ok {
2605 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2606 if err != nil {
2607 return nil, err
2608 }
2609 }
2610 args["before"] = arg1
2611 var arg2 *int
2612 if tmp, ok := rawArgs["first"]; ok {
2613 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2614 if err != nil {
2615 return nil, err
2616 }
2617 }
2618 args["first"] = arg2
2619 var arg3 *int
2620 if tmp, ok := rawArgs["last"]; ok {
2621 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2622 if err != nil {
2623 return nil, err
2624 }
2625 }
2626 args["last"] = arg3
2627 return args, nil
2628}
2629
2630func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2631 var err error
2632 args := map[string]interface{}{}
2633 var arg0 *string
2634 if tmp, ok := rawArgs["after"]; ok {
2635 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2636 if err != nil {
2637 return nil, err
2638 }
2639 }
2640 args["after"] = arg0
2641 var arg1 *string
2642 if tmp, ok := rawArgs["before"]; ok {
2643 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2644 if err != nil {
2645 return nil, err
2646 }
2647 }
2648 args["before"] = arg1
2649 var arg2 *int
2650 if tmp, ok := rawArgs["first"]; ok {
2651 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2652 if err != nil {
2653 return nil, err
2654 }
2655 }
2656 args["first"] = arg2
2657 var arg3 *int
2658 if tmp, ok := rawArgs["last"]; ok {
2659 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2660 if err != nil {
2661 return nil, err
2662 }
2663 }
2664 args["last"] = arg3
2665 return args, nil
2666}
2667
2668func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2669 var err error
2670 args := map[string]interface{}{}
2671 var arg0 *string
2672 if tmp, ok := rawArgs["after"]; ok {
2673 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2674 if err != nil {
2675 return nil, err
2676 }
2677 }
2678 args["after"] = arg0
2679 var arg1 *string
2680 if tmp, ok := rawArgs["before"]; ok {
2681 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2682 if err != nil {
2683 return nil, err
2684 }
2685 }
2686 args["before"] = arg1
2687 var arg2 *int
2688 if tmp, ok := rawArgs["first"]; ok {
2689 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2690 if err != nil {
2691 return nil, err
2692 }
2693 }
2694 args["first"] = arg2
2695 var arg3 *int
2696 if tmp, ok := rawArgs["last"]; ok {
2697 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2698 if err != nil {
2699 return nil, err
2700 }
2701 }
2702 args["last"] = arg3
2703 return args, nil
2704}
2705
2706func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2707 var err error
2708 args := map[string]interface{}{}
2709 var arg0 *string
2710 if tmp, ok := rawArgs["after"]; ok {
2711 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2712 if err != nil {
2713 return nil, err
2714 }
2715 }
2716 args["after"] = arg0
2717 var arg1 *string
2718 if tmp, ok := rawArgs["before"]; ok {
2719 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2720 if err != nil {
2721 return nil, err
2722 }
2723 }
2724 args["before"] = arg1
2725 var arg2 *int
2726 if tmp, ok := rawArgs["first"]; ok {
2727 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2728 if err != nil {
2729 return nil, err
2730 }
2731 }
2732 args["first"] = arg2
2733 var arg3 *int
2734 if tmp, ok := rawArgs["last"]; ok {
2735 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2736 if err != nil {
2737 return nil, err
2738 }
2739 }
2740 args["last"] = arg3
2741 return args, nil
2742}
2743
2744func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2745 var err error
2746 args := map[string]interface{}{}
2747 var arg0 *string
2748 if tmp, ok := rawArgs["after"]; ok {
2749 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2750 if err != nil {
2751 return nil, err
2752 }
2753 }
2754 args["after"] = arg0
2755 var arg1 *string
2756 if tmp, ok := rawArgs["before"]; ok {
2757 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2758 if err != nil {
2759 return nil, err
2760 }
2761 }
2762 args["before"] = arg1
2763 var arg2 *int
2764 if tmp, ok := rawArgs["first"]; ok {
2765 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2766 if err != nil {
2767 return nil, err
2768 }
2769 }
2770 args["first"] = arg2
2771 var arg3 *int
2772 if tmp, ok := rawArgs["last"]; ok {
2773 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2774 if err != nil {
2775 return nil, err
2776 }
2777 }
2778 args["last"] = arg3
2779 return args, nil
2780}
2781
2782func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2783 var err error
2784 args := map[string]interface{}{}
2785 var arg0 models.AddCommentInput
2786 if tmp, ok := rawArgs["input"]; ok {
2787 arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
2788 if err != nil {
2789 return nil, err
2790 }
2791 }
2792 args["input"] = arg0
2793 var arg1 *string
2794 if tmp, ok := rawArgs["txId"]; ok {
2795 arg1, err = ec.unmarshalOTxId2ᚖstring(ctx, tmp)
2796 if err != nil {
2797 return nil, err
2798 }
2799 }
2800 args["txId"] = arg1
2801 return args, nil
2802}
2803
2804func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2805 var err error
2806 args := map[string]interface{}{}
2807 var arg0 models.ChangeLabelInput
2808 if tmp, ok := rawArgs["input"]; ok {
2809 arg0, err = ec.unmarshalNChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
2810 if err != nil {
2811 return nil, err
2812 }
2813 }
2814 args["input"] = arg0
2815 var arg1 *string
2816 if tmp, ok := rawArgs["txId"]; ok {
2817 arg1, err = ec.unmarshalOTxId2ᚖstring(ctx, tmp)
2818 if err != nil {
2819 return nil, err
2820 }
2821 }
2822 args["txId"] = arg1
2823 return args, nil
2824}
2825
2826func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2827 var err error
2828 args := map[string]interface{}{}
2829 var arg0 models.CloseBugInput
2830 if tmp, ok := rawArgs["input"]; ok {
2831 arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
2832 if err != nil {
2833 return nil, err
2834 }
2835 }
2836 args["input"] = arg0
2837 var arg1 *string
2838 if tmp, ok := rawArgs["txId"]; ok {
2839 arg1, err = ec.unmarshalOTxId2ᚖstring(ctx, tmp)
2840 if err != nil {
2841 return nil, err
2842 }
2843 }
2844 args["txId"] = arg1
2845 return args, nil
2846}
2847
2848func (ec *executionContext) field_Mutation_commit_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2849 var err error
2850 args := map[string]interface{}{}
2851 var arg0 models.CommitInput
2852 if tmp, ok := rawArgs["input"]; ok {
2853 arg0, err = ec.unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx, tmp)
2854 if err != nil {
2855 return nil, err
2856 }
2857 }
2858 args["input"] = arg0
2859 return args, nil
2860}
2861
2862func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2863 var err error
2864 args := map[string]interface{}{}
2865 var arg0 models.NewBugInput
2866 if tmp, ok := rawArgs["input"]; ok {
2867 arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
2868 if err != nil {
2869 return nil, err
2870 }
2871 }
2872 args["input"] = arg0
2873 var arg1 *string
2874 if tmp, ok := rawArgs["txId"]; ok {
2875 arg1, err = ec.unmarshalOTxId2ᚖstring(ctx, tmp)
2876 if err != nil {
2877 return nil, err
2878 }
2879 }
2880 args["txId"] = arg1
2881 return args, nil
2882}
2883
2884func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2885 var err error
2886 args := map[string]interface{}{}
2887 var arg0 models.OpenBugInput
2888 if tmp, ok := rawArgs["input"]; ok {
2889 arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
2890 if err != nil {
2891 return nil, err
2892 }
2893 }
2894 args["input"] = arg0
2895 var arg1 *string
2896 if tmp, ok := rawArgs["txId"]; ok {
2897 arg1, err = ec.unmarshalOTxId2ᚖstring(ctx, tmp)
2898 if err != nil {
2899 return nil, err
2900 }
2901 }
2902 args["txId"] = arg1
2903 return args, nil
2904}
2905
2906func (ec *executionContext) field_Mutation_rollback_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.RollbackInput
2910 if tmp, ok := rawArgs["input"]; ok {
2911 arg0, err = ec.unmarshalNRollbackInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRollbackInput(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_setTitle_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.SetTitleInput
2924 if tmp, ok := rawArgs["input"]; ok {
2925 arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
2926 if err != nil {
2927 return nil, err
2928 }
2929 }
2930 args["input"] = arg0
2931 var arg1 *string
2932 if tmp, ok := rawArgs["txId"]; ok {
2933 arg1, err = ec.unmarshalOTxId2ᚖstring(ctx, tmp)
2934 if err != nil {
2935 return nil, err
2936 }
2937 }
2938 args["txId"] = arg1
2939 return args, nil
2940}
2941
2942func (ec *executionContext) field_Mutation_startTransaction_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2943 var err error
2944 args := map[string]interface{}{}
2945 var arg0 models.StartTransactionInput
2946 if tmp, ok := rawArgs["input"]; ok {
2947 arg0, err = ec.unmarshalNStartTransactionInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStartTransactionInput(ctx, tmp)
2948 if err != nil {
2949 return nil, err
2950 }
2951 }
2952 args["input"] = arg0
2953 return args, nil
2954}
2955
2956func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2957 var err error
2958 args := map[string]interface{}{}
2959 var arg0 string
2960 if tmp, ok := rawArgs["name"]; ok {
2961 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2962 if err != nil {
2963 return nil, err
2964 }
2965 }
2966 args["name"] = arg0
2967 return args, nil
2968}
2969
2970func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2971 var err error
2972 args := map[string]interface{}{}
2973 var arg0 *string
2974 if tmp, ok := rawArgs["ref"]; ok {
2975 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2976 if err != nil {
2977 return nil, err
2978 }
2979 }
2980 args["ref"] = arg0
2981 return args, nil
2982}
2983
2984func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2985 var err error
2986 args := map[string]interface{}{}
2987 var arg0 *string
2988 if tmp, ok := rawArgs["after"]; ok {
2989 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2990 if err != nil {
2991 return nil, err
2992 }
2993 }
2994 args["after"] = arg0
2995 var arg1 *string
2996 if tmp, ok := rawArgs["before"]; ok {
2997 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2998 if err != nil {
2999 return nil, err
3000 }
3001 }
3002 args["before"] = arg1
3003 var arg2 *int
3004 if tmp, ok := rawArgs["first"]; ok {
3005 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3006 if err != nil {
3007 return nil, err
3008 }
3009 }
3010 args["first"] = arg2
3011 var arg3 *int
3012 if tmp, ok := rawArgs["last"]; ok {
3013 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3014 if err != nil {
3015 return nil, err
3016 }
3017 }
3018 args["last"] = arg3
3019 var arg4 *string
3020 if tmp, ok := rawArgs["query"]; ok {
3021 arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3022 if err != nil {
3023 return nil, err
3024 }
3025 }
3026 args["query"] = arg4
3027 return args, nil
3028}
3029
3030func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3031 var err error
3032 args := map[string]interface{}{}
3033 var arg0 *string
3034 if tmp, ok := rawArgs["after"]; ok {
3035 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3036 if err != nil {
3037 return nil, err
3038 }
3039 }
3040 args["after"] = arg0
3041 var arg1 *string
3042 if tmp, ok := rawArgs["before"]; ok {
3043 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3044 if err != nil {
3045 return nil, err
3046 }
3047 }
3048 args["before"] = arg1
3049 var arg2 *int
3050 if tmp, ok := rawArgs["first"]; ok {
3051 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3052 if err != nil {
3053 return nil, err
3054 }
3055 }
3056 args["first"] = arg2
3057 var arg3 *int
3058 if tmp, ok := rawArgs["last"]; ok {
3059 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3060 if err != nil {
3061 return nil, err
3062 }
3063 }
3064 args["last"] = arg3
3065 return args, nil
3066}
3067
3068func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3069 var err error
3070 args := map[string]interface{}{}
3071 var arg0 string
3072 if tmp, ok := rawArgs["prefix"]; ok {
3073 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3074 if err != nil {
3075 return nil, err
3076 }
3077 }
3078 args["prefix"] = arg0
3079 return args, nil
3080}
3081
3082func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3083 var err error
3084 args := map[string]interface{}{}
3085 var arg0 string
3086 if tmp, ok := rawArgs["prefix"]; ok {
3087 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3088 if err != nil {
3089 return nil, err
3090 }
3091 }
3092 args["prefix"] = arg0
3093 return args, nil
3094}
3095
3096func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3097 var err error
3098 args := map[string]interface{}{}
3099 var arg0 *string
3100 if tmp, ok := rawArgs["after"]; ok {
3101 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3102 if err != nil {
3103 return nil, err
3104 }
3105 }
3106 args["after"] = arg0
3107 var arg1 *string
3108 if tmp, ok := rawArgs["before"]; ok {
3109 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
3110 if err != nil {
3111 return nil, err
3112 }
3113 }
3114 args["before"] = arg1
3115 var arg2 *int
3116 if tmp, ok := rawArgs["first"]; ok {
3117 arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3118 if err != nil {
3119 return nil, err
3120 }
3121 }
3122 args["first"] = arg2
3123 var arg3 *int
3124 if tmp, ok := rawArgs["last"]; ok {
3125 arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3126 if err != nil {
3127 return nil, err
3128 }
3129 }
3130 args["last"] = arg3
3131 return args, nil
3132}
3133
3134func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3135 var err error
3136 args := map[string]interface{}{}
3137 var arg0 bool
3138 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3139 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3140 if err != nil {
3141 return nil, err
3142 }
3143 }
3144 args["includeDeprecated"] = arg0
3145 return args, nil
3146}
3147
3148func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3149 var err error
3150 args := map[string]interface{}{}
3151 var arg0 bool
3152 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3153 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3154 if err != nil {
3155 return nil, err
3156 }
3157 }
3158 args["includeDeprecated"] = arg0
3159 return args, nil
3160}
3161
3162// endregion ***************************** args.gotpl *****************************
3163
3164// region ************************** directives.gotpl **************************
3165
3166// endregion ************************** directives.gotpl **************************
3167
3168// region **************************** field.gotpl *****************************
3169
3170func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3171 defer func() {
3172 if r := recover(); r != nil {
3173 ec.Error(ctx, ec.Recover(ctx, r))
3174 ret = graphql.Null
3175 }
3176 }()
3177 fc := &graphql.FieldContext{
3178 Object: "AddCommentOperation",
3179 Field: field,
3180 Args: nil,
3181 IsMethod: true,
3182 }
3183
3184 ctx = graphql.WithFieldContext(ctx, fc)
3185 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3186 ctx = rctx // use context from middleware stack in children
3187 return ec.resolvers.AddCommentOperation().ID(rctx, obj)
3188 })
3189 if err != nil {
3190 ec.Error(ctx, err)
3191 return graphql.Null
3192 }
3193 if resTmp == nil {
3194 if !graphql.HasFieldError(ctx, fc) {
3195 ec.Errorf(ctx, "must not be null")
3196 }
3197 return graphql.Null
3198 }
3199 res := resTmp.(string)
3200 fc.Result = res
3201 return ec.marshalNString2string(ctx, field.Selections, res)
3202}
3203
3204func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3205 defer func() {
3206 if r := recover(); r != nil {
3207 ec.Error(ctx, ec.Recover(ctx, r))
3208 ret = graphql.Null
3209 }
3210 }()
3211 fc := &graphql.FieldContext{
3212 Object: "AddCommentOperation",
3213 Field: field,
3214 Args: nil,
3215 IsMethod: true,
3216 }
3217
3218 ctx = graphql.WithFieldContext(ctx, fc)
3219 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3220 ctx = rctx // use context from middleware stack in children
3221 return ec.resolvers.AddCommentOperation().Author(rctx, obj)
3222 })
3223 if err != nil {
3224 ec.Error(ctx, err)
3225 return graphql.Null
3226 }
3227 if resTmp == nil {
3228 if !graphql.HasFieldError(ctx, fc) {
3229 ec.Errorf(ctx, "must not be null")
3230 }
3231 return graphql.Null
3232 }
3233 res := resTmp.(models.IdentityWrapper)
3234 fc.Result = res
3235 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3236}
3237
3238func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3239 defer func() {
3240 if r := recover(); r != nil {
3241 ec.Error(ctx, ec.Recover(ctx, r))
3242 ret = graphql.Null
3243 }
3244 }()
3245 fc := &graphql.FieldContext{
3246 Object: "AddCommentOperation",
3247 Field: field,
3248 Args: nil,
3249 IsMethod: true,
3250 }
3251
3252 ctx = graphql.WithFieldContext(ctx, fc)
3253 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3254 ctx = rctx // use context from middleware stack in children
3255 return ec.resolvers.AddCommentOperation().Date(rctx, obj)
3256 })
3257 if err != nil {
3258 ec.Error(ctx, err)
3259 return graphql.Null
3260 }
3261 if resTmp == nil {
3262 if !graphql.HasFieldError(ctx, fc) {
3263 ec.Errorf(ctx, "must not be null")
3264 }
3265 return graphql.Null
3266 }
3267 res := resTmp.(*time.Time)
3268 fc.Result = res
3269 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3270}
3271
3272func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3273 defer func() {
3274 if r := recover(); r != nil {
3275 ec.Error(ctx, ec.Recover(ctx, r))
3276 ret = graphql.Null
3277 }
3278 }()
3279 fc := &graphql.FieldContext{
3280 Object: "AddCommentOperation",
3281 Field: field,
3282 Args: nil,
3283 IsMethod: false,
3284 }
3285
3286 ctx = graphql.WithFieldContext(ctx, fc)
3287 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3288 ctx = rctx // use context from middleware stack in children
3289 return obj.Message, nil
3290 })
3291 if err != nil {
3292 ec.Error(ctx, err)
3293 return graphql.Null
3294 }
3295 if resTmp == nil {
3296 if !graphql.HasFieldError(ctx, fc) {
3297 ec.Errorf(ctx, "must not be null")
3298 }
3299 return graphql.Null
3300 }
3301 res := resTmp.(string)
3302 fc.Result = res
3303 return ec.marshalNString2string(ctx, field.Selections, res)
3304}
3305
3306func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
3307 defer func() {
3308 if r := recover(); r != nil {
3309 ec.Error(ctx, ec.Recover(ctx, r))
3310 ret = graphql.Null
3311 }
3312 }()
3313 fc := &graphql.FieldContext{
3314 Object: "AddCommentOperation",
3315 Field: field,
3316 Args: nil,
3317 IsMethod: false,
3318 }
3319
3320 ctx = graphql.WithFieldContext(ctx, fc)
3321 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3322 ctx = rctx // use context from middleware stack in children
3323 return obj.Files, nil
3324 })
3325 if err != nil {
3326 ec.Error(ctx, err)
3327 return graphql.Null
3328 }
3329 if resTmp == nil {
3330 if !graphql.HasFieldError(ctx, fc) {
3331 ec.Errorf(ctx, "must not be null")
3332 }
3333 return graphql.Null
3334 }
3335 res := resTmp.([]git.Hash)
3336 fc.Result = res
3337 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
3338}
3339
3340func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (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: "AddCommentPayload",
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.ClientMutationID, nil
3358 })
3359 if err != nil {
3360 ec.Error(ctx, err)
3361 return graphql.Null
3362 }
3363 if resTmp == nil {
3364 return graphql.Null
3365 }
3366 res := resTmp.(*string)
3367 fc.Result = res
3368 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
3369}
3370
3371func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3372 defer func() {
3373 if r := recover(); r != nil {
3374 ec.Error(ctx, ec.Recover(ctx, r))
3375 ret = graphql.Null
3376 }
3377 }()
3378 fc := &graphql.FieldContext{
3379 Object: "AddCommentPayload",
3380 Field: field,
3381 Args: nil,
3382 IsMethod: false,
3383 }
3384
3385 ctx = graphql.WithFieldContext(ctx, fc)
3386 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3387 ctx = rctx // use context from middleware stack in children
3388 return obj.Bug, nil
3389 })
3390 if err != nil {
3391 ec.Error(ctx, err)
3392 return graphql.Null
3393 }
3394 if resTmp == nil {
3395 if !graphql.HasFieldError(ctx, fc) {
3396 ec.Errorf(ctx, "must not be null")
3397 }
3398 return graphql.Null
3399 }
3400 res := resTmp.(models.BugWrapper)
3401 fc.Result = res
3402 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
3403}
3404
3405func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
3406 defer func() {
3407 if r := recover(); r != nil {
3408 ec.Error(ctx, ec.Recover(ctx, r))
3409 ret = graphql.Null
3410 }
3411 }()
3412 fc := &graphql.FieldContext{
3413 Object: "AddCommentPayload",
3414 Field: field,
3415 Args: nil,
3416 IsMethod: false,
3417 }
3418
3419 ctx = graphql.WithFieldContext(ctx, fc)
3420 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3421 ctx = rctx // use context from middleware stack in children
3422 return obj.Operation, nil
3423 })
3424 if err != nil {
3425 ec.Error(ctx, err)
3426 return graphql.Null
3427 }
3428 if resTmp == nil {
3429 if !graphql.HasFieldError(ctx, fc) {
3430 ec.Errorf(ctx, "must not be null")
3431 }
3432 return graphql.Null
3433 }
3434 res := resTmp.(*bug.AddCommentOperation)
3435 fc.Result = res
3436 return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
3437}
3438
3439func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3440 defer func() {
3441 if r := recover(); r != nil {
3442 ec.Error(ctx, ec.Recover(ctx, r))
3443 ret = graphql.Null
3444 }
3445 }()
3446 fc := &graphql.FieldContext{
3447 Object: "AddCommentTimelineItem",
3448 Field: field,
3449 Args: nil,
3450 IsMethod: true,
3451 }
3452
3453 ctx = graphql.WithFieldContext(ctx, fc)
3454 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3455 ctx = rctx // use context from middleware stack in children
3456 return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
3457 })
3458 if err != nil {
3459 ec.Error(ctx, err)
3460 return graphql.Null
3461 }
3462 if resTmp == nil {
3463 if !graphql.HasFieldError(ctx, fc) {
3464 ec.Errorf(ctx, "must not be null")
3465 }
3466 return graphql.Null
3467 }
3468 res := resTmp.(string)
3469 fc.Result = res
3470 return ec.marshalNString2string(ctx, field.Selections, res)
3471}
3472
3473func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3474 defer func() {
3475 if r := recover(); r != nil {
3476 ec.Error(ctx, ec.Recover(ctx, r))
3477 ret = graphql.Null
3478 }
3479 }()
3480 fc := &graphql.FieldContext{
3481 Object: "AddCommentTimelineItem",
3482 Field: field,
3483 Args: nil,
3484 IsMethod: true,
3485 }
3486
3487 ctx = graphql.WithFieldContext(ctx, fc)
3488 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3489 ctx = rctx // use context from middleware stack in children
3490 return ec.resolvers.AddCommentTimelineItem().Author(rctx, obj)
3491 })
3492 if err != nil {
3493 ec.Error(ctx, err)
3494 return graphql.Null
3495 }
3496 if resTmp == nil {
3497 if !graphql.HasFieldError(ctx, fc) {
3498 ec.Errorf(ctx, "must not be null")
3499 }
3500 return graphql.Null
3501 }
3502 res := resTmp.(models.IdentityWrapper)
3503 fc.Result = res
3504 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3505}
3506
3507func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3508 defer func() {
3509 if r := recover(); r != nil {
3510 ec.Error(ctx, ec.Recover(ctx, r))
3511 ret = graphql.Null
3512 }
3513 }()
3514 fc := &graphql.FieldContext{
3515 Object: "AddCommentTimelineItem",
3516 Field: field,
3517 Args: nil,
3518 IsMethod: false,
3519 }
3520
3521 ctx = graphql.WithFieldContext(ctx, fc)
3522 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3523 ctx = rctx // use context from middleware stack in children
3524 return obj.Message, nil
3525 })
3526 if err != nil {
3527 ec.Error(ctx, err)
3528 return graphql.Null
3529 }
3530 if resTmp == nil {
3531 if !graphql.HasFieldError(ctx, fc) {
3532 ec.Errorf(ctx, "must not be null")
3533 }
3534 return graphql.Null
3535 }
3536 res := resTmp.(string)
3537 fc.Result = res
3538 return ec.marshalNString2string(ctx, field.Selections, res)
3539}
3540
3541func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3542 defer func() {
3543 if r := recover(); r != nil {
3544 ec.Error(ctx, ec.Recover(ctx, r))
3545 ret = graphql.Null
3546 }
3547 }()
3548 fc := &graphql.FieldContext{
3549 Object: "AddCommentTimelineItem",
3550 Field: field,
3551 Args: nil,
3552 IsMethod: true,
3553 }
3554
3555 ctx = graphql.WithFieldContext(ctx, fc)
3556 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3557 ctx = rctx // use context from middleware stack in children
3558 return obj.MessageIsEmpty(), nil
3559 })
3560 if err != nil {
3561 ec.Error(ctx, err)
3562 return graphql.Null
3563 }
3564 if resTmp == nil {
3565 if !graphql.HasFieldError(ctx, fc) {
3566 ec.Errorf(ctx, "must not be null")
3567 }
3568 return graphql.Null
3569 }
3570 res := resTmp.(bool)
3571 fc.Result = res
3572 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3573}
3574
3575func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3576 defer func() {
3577 if r := recover(); r != nil {
3578 ec.Error(ctx, ec.Recover(ctx, r))
3579 ret = graphql.Null
3580 }
3581 }()
3582 fc := &graphql.FieldContext{
3583 Object: "AddCommentTimelineItem",
3584 Field: field,
3585 Args: nil,
3586 IsMethod: false,
3587 }
3588
3589 ctx = graphql.WithFieldContext(ctx, fc)
3590 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3591 ctx = rctx // use context from middleware stack in children
3592 return obj.Files, nil
3593 })
3594 if err != nil {
3595 ec.Error(ctx, err)
3596 return graphql.Null
3597 }
3598 if resTmp == nil {
3599 if !graphql.HasFieldError(ctx, fc) {
3600 ec.Errorf(ctx, "must not be null")
3601 }
3602 return graphql.Null
3603 }
3604 res := resTmp.([]git.Hash)
3605 fc.Result = res
3606 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
3607}
3608
3609func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
3610 defer func() {
3611 if r := recover(); r != nil {
3612 ec.Error(ctx, ec.Recover(ctx, r))
3613 ret = graphql.Null
3614 }
3615 }()
3616 fc := &graphql.FieldContext{
3617 Object: "AddCommentTimelineItem",
3618 Field: field,
3619 Args: nil,
3620 IsMethod: true,
3621 }
3622
3623 ctx = graphql.WithFieldContext(ctx, fc)
3624 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
3625 ctx = rctx // use context from middleware stack in children
3626 return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
3627 })
3628 if err != nil {
3629 ec.Error(ctx, err)
3630 return graphql.Null
3631 }
3632 if resTmp == nil {
3633 if !graphql.HasFieldError(ctx, fc) {
3634 ec.Errorf(ctx, "must not be null")
3635 }
3636 return graphql.Null
3637 }
3638 res := resTmp.(*time.Time)
3639 fc.Result = res
3640 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3641}
3642
3643func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (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: "AddCommentTimelineItem",
3652 Field: field,
3653 Args: nil,
3654 IsMethod: true,
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 ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
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.(*time.Time)
3673 fc.Result = res
3674 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
3675}
3676
3677func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (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: "AddCommentTimelineItem",
3686 Field: field,
3687 Args: nil,
3688 IsMethod: true,
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.Edited(), 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.(bool)
3707 fc.Result = res
3708 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
3709}
3710
3711func (ec *executionContext) _AddCommentTimelineItem_history(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: false,
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 obj.History, nil
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.([]bug.CommentHistoryStep)
3741 fc.Result = res
3742 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
3743}
3744
3745func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (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: "Bug",
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.Bug().ID(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.(string)
3775 fc.Result = res
3776 return ec.marshalNString2string(ctx, field.Selections, res)
3777}
3778
3779func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (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: "Bug",
3788 Field: field,
3789 Args: nil,
3790 IsMethod: true,
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 ec.resolvers.Bug().HumanID(rctx, obj)
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) _Bug_status(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (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: "Bug",
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 ec.resolvers.Bug().Status(rctx, obj)
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.(models.Status)
3843 fc.Result = res
3844 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
3845}
3846
3847func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (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: "Bug",
3856 Field: field,
3857 Args: nil,
3858 IsMethod: true,
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.Title(), 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.(string)
3877 fc.Result = res
3878 return ec.marshalNString2string(ctx, field.Selections, res)
3879}
3880
3881func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (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: "Bug",
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 obj.Labels(), nil
3899 })
3900 if err != nil {
3901 ec.Error(ctx, err)
3902 return graphql.Null
3903 }
3904 if resTmp == nil {
3905 if !graphql.HasFieldError(ctx, fc) {
3906 ec.Errorf(ctx, "must not be null")
3907 }
3908 return graphql.Null
3909 }
3910 res := resTmp.([]bug.Label)
3911 fc.Result = res
3912 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
3913}
3914
3915func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (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: "Bug",
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 obj.Author()
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.(models.IdentityWrapper)
3945 fc.Result = res
3946 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
3947}
3948
3949func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (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: "Bug",
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.CreatedAt(), 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.(time.Time)
3979 fc.Result = res
3980 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
3981}
3982
3983func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (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: "Bug",
3992 Field: field,
3993 Args: nil,
3994 IsMethod: true,
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.LastEdit(), 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.(time.Time)
4013 fc.Result = res
4014 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
4015}
4016
4017func (ec *executionContext) _Bug_actors(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 rawArgs := field.ArgumentMap(ec.Variables)
4033 args, err := ec.field_Bug_actors_args(ctx, rawArgs)
4034 if err != nil {
4035 ec.Error(ctx, err)
4036 return graphql.Null
4037 }
4038 fc.Args = args
4039 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4040 ctx = rctx // use context from middleware stack in children
4041 return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4042 })
4043 if err != nil {
4044 ec.Error(ctx, err)
4045 return graphql.Null
4046 }
4047 if resTmp == nil {
4048 if !graphql.HasFieldError(ctx, fc) {
4049 ec.Errorf(ctx, "must not be null")
4050 }
4051 return graphql.Null
4052 }
4053 res := resTmp.(*models.IdentityConnection)
4054 fc.Result = res
4055 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4056}
4057
4058func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4059 defer func() {
4060 if r := recover(); r != nil {
4061 ec.Error(ctx, ec.Recover(ctx, r))
4062 ret = graphql.Null
4063 }
4064 }()
4065 fc := &graphql.FieldContext{
4066 Object: "Bug",
4067 Field: field,
4068 Args: nil,
4069 IsMethod: true,
4070 }
4071
4072 ctx = graphql.WithFieldContext(ctx, fc)
4073 rawArgs := field.ArgumentMap(ec.Variables)
4074 args, err := ec.field_Bug_participants_args(ctx, rawArgs)
4075 if err != nil {
4076 ec.Error(ctx, err)
4077 return graphql.Null
4078 }
4079 fc.Args = args
4080 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4081 ctx = rctx // use context from middleware stack in children
4082 return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4083 })
4084 if err != nil {
4085 ec.Error(ctx, err)
4086 return graphql.Null
4087 }
4088 if resTmp == nil {
4089 if !graphql.HasFieldError(ctx, fc) {
4090 ec.Errorf(ctx, "must not be null")
4091 }
4092 return graphql.Null
4093 }
4094 res := resTmp.(*models.IdentityConnection)
4095 fc.Result = res
4096 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
4097}
4098
4099func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4100 defer func() {
4101 if r := recover(); r != nil {
4102 ec.Error(ctx, ec.Recover(ctx, r))
4103 ret = graphql.Null
4104 }
4105 }()
4106 fc := &graphql.FieldContext{
4107 Object: "Bug",
4108 Field: field,
4109 Args: nil,
4110 IsMethod: true,
4111 }
4112
4113 ctx = graphql.WithFieldContext(ctx, fc)
4114 rawArgs := field.ArgumentMap(ec.Variables)
4115 args, err := ec.field_Bug_comments_args(ctx, rawArgs)
4116 if err != nil {
4117 ec.Error(ctx, err)
4118 return graphql.Null
4119 }
4120 fc.Args = args
4121 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4122 ctx = rctx // use context from middleware stack in children
4123 return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4124 })
4125 if err != nil {
4126 ec.Error(ctx, err)
4127 return graphql.Null
4128 }
4129 if resTmp == nil {
4130 if !graphql.HasFieldError(ctx, fc) {
4131 ec.Errorf(ctx, "must not be null")
4132 }
4133 return graphql.Null
4134 }
4135 res := resTmp.(*models.CommentConnection)
4136 fc.Result = res
4137 return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
4138}
4139
4140func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4141 defer func() {
4142 if r := recover(); r != nil {
4143 ec.Error(ctx, ec.Recover(ctx, r))
4144 ret = graphql.Null
4145 }
4146 }()
4147 fc := &graphql.FieldContext{
4148 Object: "Bug",
4149 Field: field,
4150 Args: nil,
4151 IsMethod: true,
4152 }
4153
4154 ctx = graphql.WithFieldContext(ctx, fc)
4155 rawArgs := field.ArgumentMap(ec.Variables)
4156 args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
4157 if err != nil {
4158 ec.Error(ctx, err)
4159 return graphql.Null
4160 }
4161 fc.Args = args
4162 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4163 ctx = rctx // use context from middleware stack in children
4164 return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4165 })
4166 if err != nil {
4167 ec.Error(ctx, err)
4168 return graphql.Null
4169 }
4170 if resTmp == nil {
4171 if !graphql.HasFieldError(ctx, fc) {
4172 ec.Errorf(ctx, "must not be null")
4173 }
4174 return graphql.Null
4175 }
4176 res := resTmp.(*models.TimelineItemConnection)
4177 fc.Result = res
4178 return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
4179}
4180
4181func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
4182 defer func() {
4183 if r := recover(); r != nil {
4184 ec.Error(ctx, ec.Recover(ctx, r))
4185 ret = graphql.Null
4186 }
4187 }()
4188 fc := &graphql.FieldContext{
4189 Object: "Bug",
4190 Field: field,
4191 Args: nil,
4192 IsMethod: true,
4193 }
4194
4195 ctx = graphql.WithFieldContext(ctx, fc)
4196 rawArgs := field.ArgumentMap(ec.Variables)
4197 args, err := ec.field_Bug_operations_args(ctx, rawArgs)
4198 if err != nil {
4199 ec.Error(ctx, err)
4200 return graphql.Null
4201 }
4202 fc.Args = args
4203 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4204 ctx = rctx // use context from middleware stack in children
4205 return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
4206 })
4207 if err != nil {
4208 ec.Error(ctx, err)
4209 return graphql.Null
4210 }
4211 if resTmp == nil {
4212 if !graphql.HasFieldError(ctx, fc) {
4213 ec.Errorf(ctx, "must not be null")
4214 }
4215 return graphql.Null
4216 }
4217 res := resTmp.(*models.OperationConnection)
4218 fc.Result = res
4219 return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
4220}
4221
4222func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4223 defer func() {
4224 if r := recover(); r != nil {
4225 ec.Error(ctx, ec.Recover(ctx, r))
4226 ret = graphql.Null
4227 }
4228 }()
4229 fc := &graphql.FieldContext{
4230 Object: "BugConnection",
4231 Field: field,
4232 Args: nil,
4233 IsMethod: false,
4234 }
4235
4236 ctx = graphql.WithFieldContext(ctx, fc)
4237 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4238 ctx = rctx // use context from middleware stack in children
4239 return obj.Edges, nil
4240 })
4241 if err != nil {
4242 ec.Error(ctx, err)
4243 return graphql.Null
4244 }
4245 if resTmp == nil {
4246 if !graphql.HasFieldError(ctx, fc) {
4247 ec.Errorf(ctx, "must not be null")
4248 }
4249 return graphql.Null
4250 }
4251 res := resTmp.([]*models.BugEdge)
4252 fc.Result = res
4253 return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
4254}
4255
4256func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4257 defer func() {
4258 if r := recover(); r != nil {
4259 ec.Error(ctx, ec.Recover(ctx, r))
4260 ret = graphql.Null
4261 }
4262 }()
4263 fc := &graphql.FieldContext{
4264 Object: "BugConnection",
4265 Field: field,
4266 Args: nil,
4267 IsMethod: false,
4268 }
4269
4270 ctx = graphql.WithFieldContext(ctx, fc)
4271 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4272 ctx = rctx // use context from middleware stack in children
4273 return obj.Nodes, nil
4274 })
4275 if err != nil {
4276 ec.Error(ctx, err)
4277 return graphql.Null
4278 }
4279 if resTmp == nil {
4280 if !graphql.HasFieldError(ctx, fc) {
4281 ec.Errorf(ctx, "must not be null")
4282 }
4283 return graphql.Null
4284 }
4285 res := resTmp.([]models.BugWrapper)
4286 fc.Result = res
4287 return ec.marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx, field.Selections, res)
4288}
4289
4290func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4291 defer func() {
4292 if r := recover(); r != nil {
4293 ec.Error(ctx, ec.Recover(ctx, r))
4294 ret = graphql.Null
4295 }
4296 }()
4297 fc := &graphql.FieldContext{
4298 Object: "BugConnection",
4299 Field: field,
4300 Args: nil,
4301 IsMethod: false,
4302 }
4303
4304 ctx = graphql.WithFieldContext(ctx, fc)
4305 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4306 ctx = rctx // use context from middleware stack in children
4307 return obj.PageInfo, nil
4308 })
4309 if err != nil {
4310 ec.Error(ctx, err)
4311 return graphql.Null
4312 }
4313 if resTmp == nil {
4314 if !graphql.HasFieldError(ctx, fc) {
4315 ec.Errorf(ctx, "must not be null")
4316 }
4317 return graphql.Null
4318 }
4319 res := resTmp.(*models.PageInfo)
4320 fc.Result = res
4321 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
4322}
4323
4324func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
4325 defer func() {
4326 if r := recover(); r != nil {
4327 ec.Error(ctx, ec.Recover(ctx, r))
4328 ret = graphql.Null
4329 }
4330 }()
4331 fc := &graphql.FieldContext{
4332 Object: "BugConnection",
4333 Field: field,
4334 Args: nil,
4335 IsMethod: false,
4336 }
4337
4338 ctx = graphql.WithFieldContext(ctx, fc)
4339 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4340 ctx = rctx // use context from middleware stack in children
4341 return obj.TotalCount, nil
4342 })
4343 if err != nil {
4344 ec.Error(ctx, err)
4345 return graphql.Null
4346 }
4347 if resTmp == nil {
4348 if !graphql.HasFieldError(ctx, fc) {
4349 ec.Errorf(ctx, "must not be null")
4350 }
4351 return graphql.Null
4352 }
4353 res := resTmp.(int)
4354 fc.Result = res
4355 return ec.marshalNInt2int(ctx, field.Selections, res)
4356}
4357
4358func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4359 defer func() {
4360 if r := recover(); r != nil {
4361 ec.Error(ctx, ec.Recover(ctx, r))
4362 ret = graphql.Null
4363 }
4364 }()
4365 fc := &graphql.FieldContext{
4366 Object: "BugEdge",
4367 Field: field,
4368 Args: nil,
4369 IsMethod: false,
4370 }
4371
4372 ctx = graphql.WithFieldContext(ctx, fc)
4373 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4374 ctx = rctx // use context from middleware stack in children
4375 return obj.Cursor, nil
4376 })
4377 if err != nil {
4378 ec.Error(ctx, err)
4379 return graphql.Null
4380 }
4381 if resTmp == nil {
4382 if !graphql.HasFieldError(ctx, fc) {
4383 ec.Errorf(ctx, "must not be null")
4384 }
4385 return graphql.Null
4386 }
4387 res := resTmp.(string)
4388 fc.Result = res
4389 return ec.marshalNString2string(ctx, field.Selections, res)
4390}
4391
4392func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
4393 defer func() {
4394 if r := recover(); r != nil {
4395 ec.Error(ctx, ec.Recover(ctx, r))
4396 ret = graphql.Null
4397 }
4398 }()
4399 fc := &graphql.FieldContext{
4400 Object: "BugEdge",
4401 Field: field,
4402 Args: nil,
4403 IsMethod: false,
4404 }
4405
4406 ctx = graphql.WithFieldContext(ctx, fc)
4407 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4408 ctx = rctx // use context from middleware stack in children
4409 return obj.Node, nil
4410 })
4411 if err != nil {
4412 ec.Error(ctx, err)
4413 return graphql.Null
4414 }
4415 if resTmp == nil {
4416 if !graphql.HasFieldError(ctx, fc) {
4417 ec.Errorf(ctx, "must not be null")
4418 }
4419 return graphql.Null
4420 }
4421 res := resTmp.(models.BugWrapper)
4422 fc.Result = res
4423 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4424}
4425
4426func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4427 defer func() {
4428 if r := recover(); r != nil {
4429 ec.Error(ctx, ec.Recover(ctx, r))
4430 ret = graphql.Null
4431 }
4432 }()
4433 fc := &graphql.FieldContext{
4434 Object: "ChangeLabelPayload",
4435 Field: field,
4436 Args: nil,
4437 IsMethod: false,
4438 }
4439
4440 ctx = graphql.WithFieldContext(ctx, fc)
4441 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4442 ctx = rctx // use context from middleware stack in children
4443 return obj.ClientMutationID, nil
4444 })
4445 if err != nil {
4446 ec.Error(ctx, err)
4447 return graphql.Null
4448 }
4449 if resTmp == nil {
4450 return graphql.Null
4451 }
4452 res := resTmp.(*string)
4453 fc.Result = res
4454 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4455}
4456
4457func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4458 defer func() {
4459 if r := recover(); r != nil {
4460 ec.Error(ctx, ec.Recover(ctx, r))
4461 ret = graphql.Null
4462 }
4463 }()
4464 fc := &graphql.FieldContext{
4465 Object: "ChangeLabelPayload",
4466 Field: field,
4467 Args: nil,
4468 IsMethod: false,
4469 }
4470
4471 ctx = graphql.WithFieldContext(ctx, fc)
4472 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4473 ctx = rctx // use context from middleware stack in children
4474 return obj.Bug, nil
4475 })
4476 if err != nil {
4477 ec.Error(ctx, err)
4478 return graphql.Null
4479 }
4480 if resTmp == nil {
4481 if !graphql.HasFieldError(ctx, fc) {
4482 ec.Errorf(ctx, "must not be null")
4483 }
4484 return graphql.Null
4485 }
4486 res := resTmp.(models.BugWrapper)
4487 fc.Result = res
4488 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4489}
4490
4491func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4492 defer func() {
4493 if r := recover(); r != nil {
4494 ec.Error(ctx, ec.Recover(ctx, r))
4495 ret = graphql.Null
4496 }
4497 }()
4498 fc := &graphql.FieldContext{
4499 Object: "ChangeLabelPayload",
4500 Field: field,
4501 Args: nil,
4502 IsMethod: false,
4503 }
4504
4505 ctx = graphql.WithFieldContext(ctx, fc)
4506 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4507 ctx = rctx // use context from middleware stack in children
4508 return obj.Operation, nil
4509 })
4510 if err != nil {
4511 ec.Error(ctx, err)
4512 return graphql.Null
4513 }
4514 if resTmp == nil {
4515 if !graphql.HasFieldError(ctx, fc) {
4516 ec.Errorf(ctx, "must not be null")
4517 }
4518 return graphql.Null
4519 }
4520 res := resTmp.(*bug.LabelChangeOperation)
4521 fc.Result = res
4522 return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
4523}
4524
4525func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
4526 defer func() {
4527 if r := recover(); r != nil {
4528 ec.Error(ctx, ec.Recover(ctx, r))
4529 ret = graphql.Null
4530 }
4531 }()
4532 fc := &graphql.FieldContext{
4533 Object: "ChangeLabelPayload",
4534 Field: field,
4535 Args: nil,
4536 IsMethod: false,
4537 }
4538
4539 ctx = graphql.WithFieldContext(ctx, fc)
4540 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4541 ctx = rctx // use context from middleware stack in children
4542 return obj.Results, nil
4543 })
4544 if err != nil {
4545 ec.Error(ctx, err)
4546 return graphql.Null
4547 }
4548 if resTmp == nil {
4549 if !graphql.HasFieldError(ctx, fc) {
4550 ec.Errorf(ctx, "must not be null")
4551 }
4552 return graphql.Null
4553 }
4554 res := resTmp.([]*bug.LabelChangeResult)
4555 fc.Result = res
4556 return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
4557}
4558
4559func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4560 defer func() {
4561 if r := recover(); r != nil {
4562 ec.Error(ctx, ec.Recover(ctx, r))
4563 ret = graphql.Null
4564 }
4565 }()
4566 fc := &graphql.FieldContext{
4567 Object: "CloseBugPayload",
4568 Field: field,
4569 Args: nil,
4570 IsMethod: false,
4571 }
4572
4573 ctx = graphql.WithFieldContext(ctx, fc)
4574 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4575 ctx = rctx // use context from middleware stack in children
4576 return obj.ClientMutationID, nil
4577 })
4578 if err != nil {
4579 ec.Error(ctx, err)
4580 return graphql.Null
4581 }
4582 if resTmp == nil {
4583 return graphql.Null
4584 }
4585 res := resTmp.(*string)
4586 fc.Result = res
4587 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4588}
4589
4590func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4591 defer func() {
4592 if r := recover(); r != nil {
4593 ec.Error(ctx, ec.Recover(ctx, r))
4594 ret = graphql.Null
4595 }
4596 }()
4597 fc := &graphql.FieldContext{
4598 Object: "CloseBugPayload",
4599 Field: field,
4600 Args: nil,
4601 IsMethod: false,
4602 }
4603
4604 ctx = graphql.WithFieldContext(ctx, fc)
4605 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4606 ctx = rctx // use context from middleware stack in children
4607 return obj.Bug, nil
4608 })
4609 if err != nil {
4610 ec.Error(ctx, err)
4611 return graphql.Null
4612 }
4613 if resTmp == nil {
4614 if !graphql.HasFieldError(ctx, fc) {
4615 ec.Errorf(ctx, "must not be null")
4616 }
4617 return graphql.Null
4618 }
4619 res := resTmp.(models.BugWrapper)
4620 fc.Result = res
4621 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
4622}
4623
4624func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
4625 defer func() {
4626 if r := recover(); r != nil {
4627 ec.Error(ctx, ec.Recover(ctx, r))
4628 ret = graphql.Null
4629 }
4630 }()
4631 fc := &graphql.FieldContext{
4632 Object: "CloseBugPayload",
4633 Field: field,
4634 Args: nil,
4635 IsMethod: false,
4636 }
4637
4638 ctx = graphql.WithFieldContext(ctx, fc)
4639 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4640 ctx = rctx // use context from middleware stack in children
4641 return obj.Operation, nil
4642 })
4643 if err != nil {
4644 ec.Error(ctx, err)
4645 return graphql.Null
4646 }
4647 if resTmp == nil {
4648 if !graphql.HasFieldError(ctx, fc) {
4649 ec.Errorf(ctx, "must not be null")
4650 }
4651 return graphql.Null
4652 }
4653 res := resTmp.(*bug.SetStatusOperation)
4654 fc.Result = res
4655 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
4656}
4657
4658func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4659 defer func() {
4660 if r := recover(); r != nil {
4661 ec.Error(ctx, ec.Recover(ctx, r))
4662 ret = graphql.Null
4663 }
4664 }()
4665 fc := &graphql.FieldContext{
4666 Object: "Color",
4667 Field: field,
4668 Args: nil,
4669 IsMethod: true,
4670 }
4671
4672 ctx = graphql.WithFieldContext(ctx, fc)
4673 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4674 ctx = rctx // use context from middleware stack in children
4675 return ec.resolvers.Color().R(rctx, obj)
4676 })
4677 if err != nil {
4678 ec.Error(ctx, err)
4679 return graphql.Null
4680 }
4681 if resTmp == nil {
4682 if !graphql.HasFieldError(ctx, fc) {
4683 ec.Errorf(ctx, "must not be null")
4684 }
4685 return graphql.Null
4686 }
4687 res := resTmp.(int)
4688 fc.Result = res
4689 return ec.marshalNInt2int(ctx, field.Selections, res)
4690}
4691
4692func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4693 defer func() {
4694 if r := recover(); r != nil {
4695 ec.Error(ctx, ec.Recover(ctx, r))
4696 ret = graphql.Null
4697 }
4698 }()
4699 fc := &graphql.FieldContext{
4700 Object: "Color",
4701 Field: field,
4702 Args: nil,
4703 IsMethod: true,
4704 }
4705
4706 ctx = graphql.WithFieldContext(ctx, fc)
4707 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4708 ctx = rctx // use context from middleware stack in children
4709 return ec.resolvers.Color().G(rctx, obj)
4710 })
4711 if err != nil {
4712 ec.Error(ctx, err)
4713 return graphql.Null
4714 }
4715 if resTmp == nil {
4716 if !graphql.HasFieldError(ctx, fc) {
4717 ec.Errorf(ctx, "must not be null")
4718 }
4719 return graphql.Null
4720 }
4721 res := resTmp.(int)
4722 fc.Result = res
4723 return ec.marshalNInt2int(ctx, field.Selections, res)
4724}
4725
4726func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
4727 defer func() {
4728 if r := recover(); r != nil {
4729 ec.Error(ctx, ec.Recover(ctx, r))
4730 ret = graphql.Null
4731 }
4732 }()
4733 fc := &graphql.FieldContext{
4734 Object: "Color",
4735 Field: field,
4736 Args: nil,
4737 IsMethod: true,
4738 }
4739
4740 ctx = graphql.WithFieldContext(ctx, fc)
4741 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4742 ctx = rctx // use context from middleware stack in children
4743 return ec.resolvers.Color().B(rctx, obj)
4744 })
4745 if err != nil {
4746 ec.Error(ctx, err)
4747 return graphql.Null
4748 }
4749 if resTmp == nil {
4750 if !graphql.HasFieldError(ctx, fc) {
4751 ec.Errorf(ctx, "must not be null")
4752 }
4753 return graphql.Null
4754 }
4755 res := resTmp.(int)
4756 fc.Result = res
4757 return ec.marshalNInt2int(ctx, field.Selections, res)
4758}
4759
4760func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4761 defer func() {
4762 if r := recover(); r != nil {
4763 ec.Error(ctx, ec.Recover(ctx, r))
4764 ret = graphql.Null
4765 }
4766 }()
4767 fc := &graphql.FieldContext{
4768 Object: "Comment",
4769 Field: field,
4770 Args: nil,
4771 IsMethod: true,
4772 }
4773
4774 ctx = graphql.WithFieldContext(ctx, fc)
4775 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4776 ctx = rctx // use context from middleware stack in children
4777 return ec.resolvers.Comment().Author(rctx, obj)
4778 })
4779 if err != nil {
4780 ec.Error(ctx, err)
4781 return graphql.Null
4782 }
4783 if resTmp == nil {
4784 if !graphql.HasFieldError(ctx, fc) {
4785 ec.Errorf(ctx, "must not be null")
4786 }
4787 return graphql.Null
4788 }
4789 res := resTmp.(models.IdentityWrapper)
4790 fc.Result = res
4791 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
4792}
4793
4794func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4795 defer func() {
4796 if r := recover(); r != nil {
4797 ec.Error(ctx, ec.Recover(ctx, r))
4798 ret = graphql.Null
4799 }
4800 }()
4801 fc := &graphql.FieldContext{
4802 Object: "Comment",
4803 Field: field,
4804 Args: nil,
4805 IsMethod: false,
4806 }
4807
4808 ctx = graphql.WithFieldContext(ctx, fc)
4809 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4810 ctx = rctx // use context from middleware stack in children
4811 return obj.Message, nil
4812 })
4813 if err != nil {
4814 ec.Error(ctx, err)
4815 return graphql.Null
4816 }
4817 if resTmp == nil {
4818 if !graphql.HasFieldError(ctx, fc) {
4819 ec.Errorf(ctx, "must not be null")
4820 }
4821 return graphql.Null
4822 }
4823 res := resTmp.(string)
4824 fc.Result = res
4825 return ec.marshalNString2string(ctx, field.Selections, res)
4826}
4827
4828func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
4829 defer func() {
4830 if r := recover(); r != nil {
4831 ec.Error(ctx, ec.Recover(ctx, r))
4832 ret = graphql.Null
4833 }
4834 }()
4835 fc := &graphql.FieldContext{
4836 Object: "Comment",
4837 Field: field,
4838 Args: nil,
4839 IsMethod: false,
4840 }
4841
4842 ctx = graphql.WithFieldContext(ctx, fc)
4843 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
4844 ctx = rctx // use context from middleware stack in children
4845 return obj.Files, nil
4846 })
4847 if err != nil {
4848 ec.Error(ctx, err)
4849 return graphql.Null
4850 }
4851 if resTmp == nil {
4852 if !graphql.HasFieldError(ctx, fc) {
4853 ec.Errorf(ctx, "must not be null")
4854 }
4855 return graphql.Null
4856 }
4857 res := resTmp.([]git.Hash)
4858 fc.Result = res
4859 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
4860}
4861
4862func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (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: "CommentConnection",
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.Edges, 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.CommentEdge)
4892 fc.Result = res
4893 return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
4894}
4895
4896func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (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: "CommentConnection",
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.Nodes, 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.Comment)
4926 fc.Result = res
4927 return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx, field.Selections, res)
4928}
4929
4930func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (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: "CommentConnection",
4939 Field: field,
4940 Args: nil,
4941 IsMethod: false,
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 obj.PageInfo, nil
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.(*models.PageInfo)
4960 fc.Result = res
4961 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
4962}
4963
4964func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (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: "CommentConnection",
4973 Field: field,
4974 Args: nil,
4975 IsMethod: false,
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 obj.TotalCount, nil
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) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (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: "CommentEdge",
5007 Field: field,
5008 Args: nil,
5009 IsMethod: false,
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 obj.Cursor, nil
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.(string)
5028 fc.Result = res
5029 return ec.marshalNString2string(ctx, field.Selections, res)
5030}
5031
5032func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (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: "CommentEdge",
5041 Field: field,
5042 Args: nil,
5043 IsMethod: false,
5044 }
5045
5046 ctx = graphql.WithFieldContext(ctx, fc)
5047 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5048 ctx = rctx // use context from middleware stack in children
5049 return obj.Node, nil
5050 })
5051 if err != nil {
5052 ec.Error(ctx, err)
5053 return graphql.Null
5054 }
5055 if resTmp == nil {
5056 if !graphql.HasFieldError(ctx, fc) {
5057 ec.Errorf(ctx, "must not be null")
5058 }
5059 return graphql.Null
5060 }
5061 res := resTmp.(*bug.Comment)
5062 fc.Result = res
5063 return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
5064}
5065
5066func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (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: "CommentHistoryStep",
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) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (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: "CommentHistoryStep",
5109 Field: field,
5110 Args: nil,
5111 IsMethod: true,
5112 }
5113
5114 ctx = graphql.WithFieldContext(ctx, fc)
5115 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5116 ctx = rctx // use context from middleware stack in children
5117 return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
5118 })
5119 if err != nil {
5120 ec.Error(ctx, err)
5121 return graphql.Null
5122 }
5123 if resTmp == nil {
5124 if !graphql.HasFieldError(ctx, fc) {
5125 ec.Errorf(ctx, "must not be null")
5126 }
5127 return graphql.Null
5128 }
5129 res := resTmp.(*time.Time)
5130 fc.Result = res
5131 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5132}
5133
5134func (ec *executionContext) _CommitPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (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: "CommitPayload",
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.ClientMutationID, nil
5152 })
5153 if err != nil {
5154 ec.Error(ctx, err)
5155 return graphql.Null
5156 }
5157 if resTmp == nil {
5158 return graphql.Null
5159 }
5160 res := resTmp.(*string)
5161 fc.Result = res
5162 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
5163}
5164
5165func (ec *executionContext) _CommitPayload_id(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
5166 defer func() {
5167 if r := recover(); r != nil {
5168 ec.Error(ctx, ec.Recover(ctx, r))
5169 ret = graphql.Null
5170 }
5171 }()
5172 fc := &graphql.FieldContext{
5173 Object: "CommitPayload",
5174 Field: field,
5175 Args: nil,
5176 IsMethod: false,
5177 }
5178
5179 ctx = graphql.WithFieldContext(ctx, fc)
5180 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5181 ctx = rctx // use context from middleware stack in children
5182 return obj.ID, nil
5183 })
5184 if err != nil {
5185 ec.Error(ctx, err)
5186 return graphql.Null
5187 }
5188 if resTmp == nil {
5189 if !graphql.HasFieldError(ctx, fc) {
5190 ec.Errorf(ctx, "must not be null")
5191 }
5192 return graphql.Null
5193 }
5194 res := resTmp.(string)
5195 fc.Result = res
5196 return ec.marshalNTxId2string(ctx, field.Selections, res)
5197}
5198
5199func (ec *executionContext) _CommitPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
5200 defer func() {
5201 if r := recover(); r != nil {
5202 ec.Error(ctx, ec.Recover(ctx, r))
5203 ret = graphql.Null
5204 }
5205 }()
5206 fc := &graphql.FieldContext{
5207 Object: "CommitPayload",
5208 Field: field,
5209 Args: nil,
5210 IsMethod: false,
5211 }
5212
5213 ctx = graphql.WithFieldContext(ctx, fc)
5214 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5215 ctx = rctx // use context from middleware stack in children
5216 return obj.Bug, nil
5217 })
5218 if err != nil {
5219 ec.Error(ctx, err)
5220 return graphql.Null
5221 }
5222 if resTmp == nil {
5223 if !graphql.HasFieldError(ctx, fc) {
5224 ec.Errorf(ctx, "must not be null")
5225 }
5226 return graphql.Null
5227 }
5228 res := resTmp.(models.BugWrapper)
5229 fc.Result = res
5230 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
5231}
5232
5233func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5234 defer func() {
5235 if r := recover(); r != nil {
5236 ec.Error(ctx, ec.Recover(ctx, r))
5237 ret = graphql.Null
5238 }
5239 }()
5240 fc := &graphql.FieldContext{
5241 Object: "CreateOperation",
5242 Field: field,
5243 Args: nil,
5244 IsMethod: true,
5245 }
5246
5247 ctx = graphql.WithFieldContext(ctx, fc)
5248 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5249 ctx = rctx // use context from middleware stack in children
5250 return ec.resolvers.CreateOperation().ID(rctx, obj)
5251 })
5252 if err != nil {
5253 ec.Error(ctx, err)
5254 return graphql.Null
5255 }
5256 if resTmp == nil {
5257 if !graphql.HasFieldError(ctx, fc) {
5258 ec.Errorf(ctx, "must not be null")
5259 }
5260 return graphql.Null
5261 }
5262 res := resTmp.(string)
5263 fc.Result = res
5264 return ec.marshalNString2string(ctx, field.Selections, res)
5265}
5266
5267func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5268 defer func() {
5269 if r := recover(); r != nil {
5270 ec.Error(ctx, ec.Recover(ctx, r))
5271 ret = graphql.Null
5272 }
5273 }()
5274 fc := &graphql.FieldContext{
5275 Object: "CreateOperation",
5276 Field: field,
5277 Args: nil,
5278 IsMethod: true,
5279 }
5280
5281 ctx = graphql.WithFieldContext(ctx, fc)
5282 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5283 ctx = rctx // use context from middleware stack in children
5284 return ec.resolvers.CreateOperation().Author(rctx, obj)
5285 })
5286 if err != nil {
5287 ec.Error(ctx, err)
5288 return graphql.Null
5289 }
5290 if resTmp == nil {
5291 if !graphql.HasFieldError(ctx, fc) {
5292 ec.Errorf(ctx, "must not be null")
5293 }
5294 return graphql.Null
5295 }
5296 res := resTmp.(models.IdentityWrapper)
5297 fc.Result = res
5298 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5299}
5300
5301func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5302 defer func() {
5303 if r := recover(); r != nil {
5304 ec.Error(ctx, ec.Recover(ctx, r))
5305 ret = graphql.Null
5306 }
5307 }()
5308 fc := &graphql.FieldContext{
5309 Object: "CreateOperation",
5310 Field: field,
5311 Args: nil,
5312 IsMethod: true,
5313 }
5314
5315 ctx = graphql.WithFieldContext(ctx, fc)
5316 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5317 ctx = rctx // use context from middleware stack in children
5318 return ec.resolvers.CreateOperation().Date(rctx, obj)
5319 })
5320 if err != nil {
5321 ec.Error(ctx, err)
5322 return graphql.Null
5323 }
5324 if resTmp == nil {
5325 if !graphql.HasFieldError(ctx, fc) {
5326 ec.Errorf(ctx, "must not be null")
5327 }
5328 return graphql.Null
5329 }
5330 res := resTmp.(*time.Time)
5331 fc.Result = res
5332 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5333}
5334
5335func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5336 defer func() {
5337 if r := recover(); r != nil {
5338 ec.Error(ctx, ec.Recover(ctx, r))
5339 ret = graphql.Null
5340 }
5341 }()
5342 fc := &graphql.FieldContext{
5343 Object: "CreateOperation",
5344 Field: field,
5345 Args: nil,
5346 IsMethod: false,
5347 }
5348
5349 ctx = graphql.WithFieldContext(ctx, fc)
5350 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5351 ctx = rctx // use context from middleware stack in children
5352 return obj.Title, nil
5353 })
5354 if err != nil {
5355 ec.Error(ctx, err)
5356 return graphql.Null
5357 }
5358 if resTmp == nil {
5359 if !graphql.HasFieldError(ctx, fc) {
5360 ec.Errorf(ctx, "must not be null")
5361 }
5362 return graphql.Null
5363 }
5364 res := resTmp.(string)
5365 fc.Result = res
5366 return ec.marshalNString2string(ctx, field.Selections, res)
5367}
5368
5369func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5370 defer func() {
5371 if r := recover(); r != nil {
5372 ec.Error(ctx, ec.Recover(ctx, r))
5373 ret = graphql.Null
5374 }
5375 }()
5376 fc := &graphql.FieldContext{
5377 Object: "CreateOperation",
5378 Field: field,
5379 Args: nil,
5380 IsMethod: false,
5381 }
5382
5383 ctx = graphql.WithFieldContext(ctx, fc)
5384 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5385 ctx = rctx // use context from middleware stack in children
5386 return obj.Message, nil
5387 })
5388 if err != nil {
5389 ec.Error(ctx, err)
5390 return graphql.Null
5391 }
5392 if resTmp == nil {
5393 if !graphql.HasFieldError(ctx, fc) {
5394 ec.Errorf(ctx, "must not be null")
5395 }
5396 return graphql.Null
5397 }
5398 res := resTmp.(string)
5399 fc.Result = res
5400 return ec.marshalNString2string(ctx, field.Selections, res)
5401}
5402
5403func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
5404 defer func() {
5405 if r := recover(); r != nil {
5406 ec.Error(ctx, ec.Recover(ctx, r))
5407 ret = graphql.Null
5408 }
5409 }()
5410 fc := &graphql.FieldContext{
5411 Object: "CreateOperation",
5412 Field: field,
5413 Args: nil,
5414 IsMethod: false,
5415 }
5416
5417 ctx = graphql.WithFieldContext(ctx, fc)
5418 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5419 ctx = rctx // use context from middleware stack in children
5420 return obj.Files, nil
5421 })
5422 if err != nil {
5423 ec.Error(ctx, err)
5424 return graphql.Null
5425 }
5426 if resTmp == nil {
5427 if !graphql.HasFieldError(ctx, fc) {
5428 ec.Errorf(ctx, "must not be null")
5429 }
5430 return graphql.Null
5431 }
5432 res := resTmp.([]git.Hash)
5433 fc.Result = res
5434 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
5435}
5436
5437func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5438 defer func() {
5439 if r := recover(); r != nil {
5440 ec.Error(ctx, ec.Recover(ctx, r))
5441 ret = graphql.Null
5442 }
5443 }()
5444 fc := &graphql.FieldContext{
5445 Object: "CreateTimelineItem",
5446 Field: field,
5447 Args: nil,
5448 IsMethod: true,
5449 }
5450
5451 ctx = graphql.WithFieldContext(ctx, fc)
5452 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5453 ctx = rctx // use context from middleware stack in children
5454 return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
5455 })
5456 if err != nil {
5457 ec.Error(ctx, err)
5458 return graphql.Null
5459 }
5460 if resTmp == nil {
5461 if !graphql.HasFieldError(ctx, fc) {
5462 ec.Errorf(ctx, "must not be null")
5463 }
5464 return graphql.Null
5465 }
5466 res := resTmp.(string)
5467 fc.Result = res
5468 return ec.marshalNString2string(ctx, field.Selections, res)
5469}
5470
5471func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5472 defer func() {
5473 if r := recover(); r != nil {
5474 ec.Error(ctx, ec.Recover(ctx, r))
5475 ret = graphql.Null
5476 }
5477 }()
5478 fc := &graphql.FieldContext{
5479 Object: "CreateTimelineItem",
5480 Field: field,
5481 Args: nil,
5482 IsMethod: true,
5483 }
5484
5485 ctx = graphql.WithFieldContext(ctx, fc)
5486 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5487 ctx = rctx // use context from middleware stack in children
5488 return ec.resolvers.CreateTimelineItem().Author(rctx, obj)
5489 })
5490 if err != nil {
5491 ec.Error(ctx, err)
5492 return graphql.Null
5493 }
5494 if resTmp == nil {
5495 if !graphql.HasFieldError(ctx, fc) {
5496 ec.Errorf(ctx, "must not be null")
5497 }
5498 return graphql.Null
5499 }
5500 res := resTmp.(models.IdentityWrapper)
5501 fc.Result = res
5502 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5503}
5504
5505func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5506 defer func() {
5507 if r := recover(); r != nil {
5508 ec.Error(ctx, ec.Recover(ctx, r))
5509 ret = graphql.Null
5510 }
5511 }()
5512 fc := &graphql.FieldContext{
5513 Object: "CreateTimelineItem",
5514 Field: field,
5515 Args: nil,
5516 IsMethod: false,
5517 }
5518
5519 ctx = graphql.WithFieldContext(ctx, fc)
5520 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5521 ctx = rctx // use context from middleware stack in children
5522 return obj.Message, nil
5523 })
5524 if err != nil {
5525 ec.Error(ctx, err)
5526 return graphql.Null
5527 }
5528 if resTmp == nil {
5529 if !graphql.HasFieldError(ctx, fc) {
5530 ec.Errorf(ctx, "must not be null")
5531 }
5532 return graphql.Null
5533 }
5534 res := resTmp.(string)
5535 fc.Result = res
5536 return ec.marshalNString2string(ctx, field.Selections, res)
5537}
5538
5539func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5540 defer func() {
5541 if r := recover(); r != nil {
5542 ec.Error(ctx, ec.Recover(ctx, r))
5543 ret = graphql.Null
5544 }
5545 }()
5546 fc := &graphql.FieldContext{
5547 Object: "CreateTimelineItem",
5548 Field: field,
5549 Args: nil,
5550 IsMethod: true,
5551 }
5552
5553 ctx = graphql.WithFieldContext(ctx, fc)
5554 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5555 ctx = rctx // use context from middleware stack in children
5556 return obj.MessageIsEmpty(), nil
5557 })
5558 if err != nil {
5559 ec.Error(ctx, err)
5560 return graphql.Null
5561 }
5562 if resTmp == nil {
5563 if !graphql.HasFieldError(ctx, fc) {
5564 ec.Errorf(ctx, "must not be null")
5565 }
5566 return graphql.Null
5567 }
5568 res := resTmp.(bool)
5569 fc.Result = res
5570 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5571}
5572
5573func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5574 defer func() {
5575 if r := recover(); r != nil {
5576 ec.Error(ctx, ec.Recover(ctx, r))
5577 ret = graphql.Null
5578 }
5579 }()
5580 fc := &graphql.FieldContext{
5581 Object: "CreateTimelineItem",
5582 Field: field,
5583 Args: nil,
5584 IsMethod: false,
5585 }
5586
5587 ctx = graphql.WithFieldContext(ctx, fc)
5588 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5589 ctx = rctx // use context from middleware stack in children
5590 return obj.Files, nil
5591 })
5592 if err != nil {
5593 ec.Error(ctx, err)
5594 return graphql.Null
5595 }
5596 if resTmp == nil {
5597 if !graphql.HasFieldError(ctx, fc) {
5598 ec.Errorf(ctx, "must not be null")
5599 }
5600 return graphql.Null
5601 }
5602 res := resTmp.([]git.Hash)
5603 fc.Result = res
5604 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
5605}
5606
5607func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5608 defer func() {
5609 if r := recover(); r != nil {
5610 ec.Error(ctx, ec.Recover(ctx, r))
5611 ret = graphql.Null
5612 }
5613 }()
5614 fc := &graphql.FieldContext{
5615 Object: "CreateTimelineItem",
5616 Field: field,
5617 Args: nil,
5618 IsMethod: true,
5619 }
5620
5621 ctx = graphql.WithFieldContext(ctx, fc)
5622 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5623 ctx = rctx // use context from middleware stack in children
5624 return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
5625 })
5626 if err != nil {
5627 ec.Error(ctx, err)
5628 return graphql.Null
5629 }
5630 if resTmp == nil {
5631 if !graphql.HasFieldError(ctx, fc) {
5632 ec.Errorf(ctx, "must not be null")
5633 }
5634 return graphql.Null
5635 }
5636 res := resTmp.(*time.Time)
5637 fc.Result = res
5638 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5639}
5640
5641func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5642 defer func() {
5643 if r := recover(); r != nil {
5644 ec.Error(ctx, ec.Recover(ctx, r))
5645 ret = graphql.Null
5646 }
5647 }()
5648 fc := &graphql.FieldContext{
5649 Object: "CreateTimelineItem",
5650 Field: field,
5651 Args: nil,
5652 IsMethod: true,
5653 }
5654
5655 ctx = graphql.WithFieldContext(ctx, fc)
5656 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5657 ctx = rctx // use context from middleware stack in children
5658 return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
5659 })
5660 if err != nil {
5661 ec.Error(ctx, err)
5662 return graphql.Null
5663 }
5664 if resTmp == nil {
5665 if !graphql.HasFieldError(ctx, fc) {
5666 ec.Errorf(ctx, "must not be null")
5667 }
5668 return graphql.Null
5669 }
5670 res := resTmp.(*time.Time)
5671 fc.Result = res
5672 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5673}
5674
5675func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5676 defer func() {
5677 if r := recover(); r != nil {
5678 ec.Error(ctx, ec.Recover(ctx, r))
5679 ret = graphql.Null
5680 }
5681 }()
5682 fc := &graphql.FieldContext{
5683 Object: "CreateTimelineItem",
5684 Field: field,
5685 Args: nil,
5686 IsMethod: true,
5687 }
5688
5689 ctx = graphql.WithFieldContext(ctx, fc)
5690 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5691 ctx = rctx // use context from middleware stack in children
5692 return obj.Edited(), nil
5693 })
5694 if err != nil {
5695 ec.Error(ctx, err)
5696 return graphql.Null
5697 }
5698 if resTmp == nil {
5699 if !graphql.HasFieldError(ctx, fc) {
5700 ec.Errorf(ctx, "must not be null")
5701 }
5702 return graphql.Null
5703 }
5704 res := resTmp.(bool)
5705 fc.Result = res
5706 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
5707}
5708
5709func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
5710 defer func() {
5711 if r := recover(); r != nil {
5712 ec.Error(ctx, ec.Recover(ctx, r))
5713 ret = graphql.Null
5714 }
5715 }()
5716 fc := &graphql.FieldContext{
5717 Object: "CreateTimelineItem",
5718 Field: field,
5719 Args: nil,
5720 IsMethod: false,
5721 }
5722
5723 ctx = graphql.WithFieldContext(ctx, fc)
5724 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5725 ctx = rctx // use context from middleware stack in children
5726 return obj.History, nil
5727 })
5728 if err != nil {
5729 ec.Error(ctx, err)
5730 return graphql.Null
5731 }
5732 if resTmp == nil {
5733 if !graphql.HasFieldError(ctx, fc) {
5734 ec.Errorf(ctx, "must not be null")
5735 }
5736 return graphql.Null
5737 }
5738 res := resTmp.([]bug.CommentHistoryStep)
5739 fc.Result = res
5740 return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
5741}
5742
5743func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5744 defer func() {
5745 if r := recover(); r != nil {
5746 ec.Error(ctx, ec.Recover(ctx, r))
5747 ret = graphql.Null
5748 }
5749 }()
5750 fc := &graphql.FieldContext{
5751 Object: "EditCommentOperation",
5752 Field: field,
5753 Args: nil,
5754 IsMethod: true,
5755 }
5756
5757 ctx = graphql.WithFieldContext(ctx, fc)
5758 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5759 ctx = rctx // use context from middleware stack in children
5760 return ec.resolvers.EditCommentOperation().ID(rctx, obj)
5761 })
5762 if err != nil {
5763 ec.Error(ctx, err)
5764 return graphql.Null
5765 }
5766 if resTmp == nil {
5767 if !graphql.HasFieldError(ctx, fc) {
5768 ec.Errorf(ctx, "must not be null")
5769 }
5770 return graphql.Null
5771 }
5772 res := resTmp.(string)
5773 fc.Result = res
5774 return ec.marshalNString2string(ctx, field.Selections, res)
5775}
5776
5777func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5778 defer func() {
5779 if r := recover(); r != nil {
5780 ec.Error(ctx, ec.Recover(ctx, r))
5781 ret = graphql.Null
5782 }
5783 }()
5784 fc := &graphql.FieldContext{
5785 Object: "EditCommentOperation",
5786 Field: field,
5787 Args: nil,
5788 IsMethod: true,
5789 }
5790
5791 ctx = graphql.WithFieldContext(ctx, fc)
5792 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5793 ctx = rctx // use context from middleware stack in children
5794 return ec.resolvers.EditCommentOperation().Author(rctx, obj)
5795 })
5796 if err != nil {
5797 ec.Error(ctx, err)
5798 return graphql.Null
5799 }
5800 if resTmp == nil {
5801 if !graphql.HasFieldError(ctx, fc) {
5802 ec.Errorf(ctx, "must not be null")
5803 }
5804 return graphql.Null
5805 }
5806 res := resTmp.(models.IdentityWrapper)
5807 fc.Result = res
5808 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
5809}
5810
5811func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5812 defer func() {
5813 if r := recover(); r != nil {
5814 ec.Error(ctx, ec.Recover(ctx, r))
5815 ret = graphql.Null
5816 }
5817 }()
5818 fc := &graphql.FieldContext{
5819 Object: "EditCommentOperation",
5820 Field: field,
5821 Args: nil,
5822 IsMethod: true,
5823 }
5824
5825 ctx = graphql.WithFieldContext(ctx, fc)
5826 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5827 ctx = rctx // use context from middleware stack in children
5828 return ec.resolvers.EditCommentOperation().Date(rctx, obj)
5829 })
5830 if err != nil {
5831 ec.Error(ctx, err)
5832 return graphql.Null
5833 }
5834 if resTmp == nil {
5835 if !graphql.HasFieldError(ctx, fc) {
5836 ec.Errorf(ctx, "must not be null")
5837 }
5838 return graphql.Null
5839 }
5840 res := resTmp.(*time.Time)
5841 fc.Result = res
5842 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
5843}
5844
5845func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5846 defer func() {
5847 if r := recover(); r != nil {
5848 ec.Error(ctx, ec.Recover(ctx, r))
5849 ret = graphql.Null
5850 }
5851 }()
5852 fc := &graphql.FieldContext{
5853 Object: "EditCommentOperation",
5854 Field: field,
5855 Args: nil,
5856 IsMethod: true,
5857 }
5858
5859 ctx = graphql.WithFieldContext(ctx, fc)
5860 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5861 ctx = rctx // use context from middleware stack in children
5862 return ec.resolvers.EditCommentOperation().Target(rctx, obj)
5863 })
5864 if err != nil {
5865 ec.Error(ctx, err)
5866 return graphql.Null
5867 }
5868 if resTmp == nil {
5869 if !graphql.HasFieldError(ctx, fc) {
5870 ec.Errorf(ctx, "must not be null")
5871 }
5872 return graphql.Null
5873 }
5874 res := resTmp.(string)
5875 fc.Result = res
5876 return ec.marshalNString2string(ctx, field.Selections, res)
5877}
5878
5879func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5880 defer func() {
5881 if r := recover(); r != nil {
5882 ec.Error(ctx, ec.Recover(ctx, r))
5883 ret = graphql.Null
5884 }
5885 }()
5886 fc := &graphql.FieldContext{
5887 Object: "EditCommentOperation",
5888 Field: field,
5889 Args: nil,
5890 IsMethod: false,
5891 }
5892
5893 ctx = graphql.WithFieldContext(ctx, fc)
5894 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5895 ctx = rctx // use context from middleware stack in children
5896 return obj.Message, nil
5897 })
5898 if err != nil {
5899 ec.Error(ctx, err)
5900 return graphql.Null
5901 }
5902 if resTmp == nil {
5903 if !graphql.HasFieldError(ctx, fc) {
5904 ec.Errorf(ctx, "must not be null")
5905 }
5906 return graphql.Null
5907 }
5908 res := resTmp.(string)
5909 fc.Result = res
5910 return ec.marshalNString2string(ctx, field.Selections, res)
5911}
5912
5913func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
5914 defer func() {
5915 if r := recover(); r != nil {
5916 ec.Error(ctx, ec.Recover(ctx, r))
5917 ret = graphql.Null
5918 }
5919 }()
5920 fc := &graphql.FieldContext{
5921 Object: "EditCommentOperation",
5922 Field: field,
5923 Args: nil,
5924 IsMethod: false,
5925 }
5926
5927 ctx = graphql.WithFieldContext(ctx, fc)
5928 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5929 ctx = rctx // use context from middleware stack in children
5930 return obj.Files, nil
5931 })
5932 if err != nil {
5933 ec.Error(ctx, err)
5934 return graphql.Null
5935 }
5936 if resTmp == nil {
5937 if !graphql.HasFieldError(ctx, fc) {
5938 ec.Errorf(ctx, "must not be null")
5939 }
5940 return graphql.Null
5941 }
5942 res := resTmp.([]git.Hash)
5943 fc.Result = res
5944 return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
5945}
5946
5947func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
5948 defer func() {
5949 if r := recover(); r != nil {
5950 ec.Error(ctx, ec.Recover(ctx, r))
5951 ret = graphql.Null
5952 }
5953 }()
5954 fc := &graphql.FieldContext{
5955 Object: "Identity",
5956 Field: field,
5957 Args: nil,
5958 IsMethod: true,
5959 }
5960
5961 ctx = graphql.WithFieldContext(ctx, fc)
5962 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5963 ctx = rctx // use context from middleware stack in children
5964 return ec.resolvers.Identity().ID(rctx, obj)
5965 })
5966 if err != nil {
5967 ec.Error(ctx, err)
5968 return graphql.Null
5969 }
5970 if resTmp == nil {
5971 if !graphql.HasFieldError(ctx, fc) {
5972 ec.Errorf(ctx, "must not be null")
5973 }
5974 return graphql.Null
5975 }
5976 res := resTmp.(string)
5977 fc.Result = res
5978 return ec.marshalNString2string(ctx, field.Selections, res)
5979}
5980
5981func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
5982 defer func() {
5983 if r := recover(); r != nil {
5984 ec.Error(ctx, ec.Recover(ctx, r))
5985 ret = graphql.Null
5986 }
5987 }()
5988 fc := &graphql.FieldContext{
5989 Object: "Identity",
5990 Field: field,
5991 Args: nil,
5992 IsMethod: true,
5993 }
5994
5995 ctx = graphql.WithFieldContext(ctx, fc)
5996 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
5997 ctx = rctx // use context from middleware stack in children
5998 return ec.resolvers.Identity().HumanID(rctx, obj)
5999 })
6000 if err != nil {
6001 ec.Error(ctx, err)
6002 return graphql.Null
6003 }
6004 if resTmp == nil {
6005 if !graphql.HasFieldError(ctx, fc) {
6006 ec.Errorf(ctx, "must not be null")
6007 }
6008 return graphql.Null
6009 }
6010 res := resTmp.(string)
6011 fc.Result = res
6012 return ec.marshalNString2string(ctx, field.Selections, res)
6013}
6014
6015func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6016 defer func() {
6017 if r := recover(); r != nil {
6018 ec.Error(ctx, ec.Recover(ctx, r))
6019 ret = graphql.Null
6020 }
6021 }()
6022 fc := &graphql.FieldContext{
6023 Object: "Identity",
6024 Field: field,
6025 Args: nil,
6026 IsMethod: true,
6027 }
6028
6029 ctx = graphql.WithFieldContext(ctx, fc)
6030 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6031 ctx = rctx // use context from middleware stack in children
6032 return obj.Name(), nil
6033 })
6034 if err != nil {
6035 ec.Error(ctx, err)
6036 return graphql.Null
6037 }
6038 if resTmp == nil {
6039 return graphql.Null
6040 }
6041 res := resTmp.(string)
6042 fc.Result = res
6043 return ec.marshalOString2string(ctx, field.Selections, res)
6044}
6045
6046func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6047 defer func() {
6048 if r := recover(); r != nil {
6049 ec.Error(ctx, ec.Recover(ctx, r))
6050 ret = graphql.Null
6051 }
6052 }()
6053 fc := &graphql.FieldContext{
6054 Object: "Identity",
6055 Field: field,
6056 Args: nil,
6057 IsMethod: true,
6058 }
6059
6060 ctx = graphql.WithFieldContext(ctx, fc)
6061 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6062 ctx = rctx // use context from middleware stack in children
6063 return obj.Email()
6064 })
6065 if err != nil {
6066 ec.Error(ctx, err)
6067 return graphql.Null
6068 }
6069 if resTmp == nil {
6070 return graphql.Null
6071 }
6072 res := resTmp.(string)
6073 fc.Result = res
6074 return ec.marshalOString2string(ctx, field.Selections, res)
6075}
6076
6077func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6078 defer func() {
6079 if r := recover(); r != nil {
6080 ec.Error(ctx, ec.Recover(ctx, r))
6081 ret = graphql.Null
6082 }
6083 }()
6084 fc := &graphql.FieldContext{
6085 Object: "Identity",
6086 Field: field,
6087 Args: nil,
6088 IsMethod: true,
6089 }
6090
6091 ctx = graphql.WithFieldContext(ctx, fc)
6092 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6093 ctx = rctx // use context from middleware stack in children
6094 return obj.DisplayName(), nil
6095 })
6096 if err != nil {
6097 ec.Error(ctx, err)
6098 return graphql.Null
6099 }
6100 if resTmp == nil {
6101 if !graphql.HasFieldError(ctx, fc) {
6102 ec.Errorf(ctx, "must not be null")
6103 }
6104 return graphql.Null
6105 }
6106 res := resTmp.(string)
6107 fc.Result = res
6108 return ec.marshalNString2string(ctx, field.Selections, res)
6109}
6110
6111func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6112 defer func() {
6113 if r := recover(); r != nil {
6114 ec.Error(ctx, ec.Recover(ctx, r))
6115 ret = graphql.Null
6116 }
6117 }()
6118 fc := &graphql.FieldContext{
6119 Object: "Identity",
6120 Field: field,
6121 Args: nil,
6122 IsMethod: true,
6123 }
6124
6125 ctx = graphql.WithFieldContext(ctx, fc)
6126 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6127 ctx = rctx // use context from middleware stack in children
6128 return obj.AvatarUrl()
6129 })
6130 if err != nil {
6131 ec.Error(ctx, err)
6132 return graphql.Null
6133 }
6134 if resTmp == nil {
6135 return graphql.Null
6136 }
6137 res := resTmp.(string)
6138 fc.Result = res
6139 return ec.marshalOString2string(ctx, field.Selections, res)
6140}
6141
6142func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
6143 defer func() {
6144 if r := recover(); r != nil {
6145 ec.Error(ctx, ec.Recover(ctx, r))
6146 ret = graphql.Null
6147 }
6148 }()
6149 fc := &graphql.FieldContext{
6150 Object: "Identity",
6151 Field: field,
6152 Args: nil,
6153 IsMethod: true,
6154 }
6155
6156 ctx = graphql.WithFieldContext(ctx, fc)
6157 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6158 ctx = rctx // use context from middleware stack in children
6159 return obj.IsProtected()
6160 })
6161 if err != nil {
6162 ec.Error(ctx, err)
6163 return graphql.Null
6164 }
6165 if resTmp == nil {
6166 if !graphql.HasFieldError(ctx, fc) {
6167 ec.Errorf(ctx, "must not be null")
6168 }
6169 return graphql.Null
6170 }
6171 res := resTmp.(bool)
6172 fc.Result = res
6173 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
6174}
6175
6176func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6177 defer func() {
6178 if r := recover(); r != nil {
6179 ec.Error(ctx, ec.Recover(ctx, r))
6180 ret = graphql.Null
6181 }
6182 }()
6183 fc := &graphql.FieldContext{
6184 Object: "IdentityConnection",
6185 Field: field,
6186 Args: nil,
6187 IsMethod: false,
6188 }
6189
6190 ctx = graphql.WithFieldContext(ctx, fc)
6191 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6192 ctx = rctx // use context from middleware stack in children
6193 return obj.Edges, nil
6194 })
6195 if err != nil {
6196 ec.Error(ctx, err)
6197 return graphql.Null
6198 }
6199 if resTmp == nil {
6200 if !graphql.HasFieldError(ctx, fc) {
6201 ec.Errorf(ctx, "must not be null")
6202 }
6203 return graphql.Null
6204 }
6205 res := resTmp.([]*models.IdentityEdge)
6206 fc.Result = res
6207 return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx, field.Selections, res)
6208}
6209
6210func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6211 defer func() {
6212 if r := recover(); r != nil {
6213 ec.Error(ctx, ec.Recover(ctx, r))
6214 ret = graphql.Null
6215 }
6216 }()
6217 fc := &graphql.FieldContext{
6218 Object: "IdentityConnection",
6219 Field: field,
6220 Args: nil,
6221 IsMethod: false,
6222 }
6223
6224 ctx = graphql.WithFieldContext(ctx, fc)
6225 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6226 ctx = rctx // use context from middleware stack in children
6227 return obj.Nodes, nil
6228 })
6229 if err != nil {
6230 ec.Error(ctx, err)
6231 return graphql.Null
6232 }
6233 if resTmp == nil {
6234 if !graphql.HasFieldError(ctx, fc) {
6235 ec.Errorf(ctx, "must not be null")
6236 }
6237 return graphql.Null
6238 }
6239 res := resTmp.([]models.IdentityWrapper)
6240 fc.Result = res
6241 return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx, field.Selections, res)
6242}
6243
6244func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6245 defer func() {
6246 if r := recover(); r != nil {
6247 ec.Error(ctx, ec.Recover(ctx, r))
6248 ret = graphql.Null
6249 }
6250 }()
6251 fc := &graphql.FieldContext{
6252 Object: "IdentityConnection",
6253 Field: field,
6254 Args: nil,
6255 IsMethod: false,
6256 }
6257
6258 ctx = graphql.WithFieldContext(ctx, fc)
6259 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6260 ctx = rctx // use context from middleware stack in children
6261 return obj.PageInfo, nil
6262 })
6263 if err != nil {
6264 ec.Error(ctx, err)
6265 return graphql.Null
6266 }
6267 if resTmp == nil {
6268 if !graphql.HasFieldError(ctx, fc) {
6269 ec.Errorf(ctx, "must not be null")
6270 }
6271 return graphql.Null
6272 }
6273 res := resTmp.(*models.PageInfo)
6274 fc.Result = res
6275 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
6276}
6277
6278func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
6279 defer func() {
6280 if r := recover(); r != nil {
6281 ec.Error(ctx, ec.Recover(ctx, r))
6282 ret = graphql.Null
6283 }
6284 }()
6285 fc := &graphql.FieldContext{
6286 Object: "IdentityConnection",
6287 Field: field,
6288 Args: nil,
6289 IsMethod: false,
6290 }
6291
6292 ctx = graphql.WithFieldContext(ctx, fc)
6293 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6294 ctx = rctx // use context from middleware stack in children
6295 return obj.TotalCount, nil
6296 })
6297 if err != nil {
6298 ec.Error(ctx, err)
6299 return graphql.Null
6300 }
6301 if resTmp == nil {
6302 if !graphql.HasFieldError(ctx, fc) {
6303 ec.Errorf(ctx, "must not be null")
6304 }
6305 return graphql.Null
6306 }
6307 res := resTmp.(int)
6308 fc.Result = res
6309 return ec.marshalNInt2int(ctx, field.Selections, res)
6310}
6311
6312func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6313 defer func() {
6314 if r := recover(); r != nil {
6315 ec.Error(ctx, ec.Recover(ctx, r))
6316 ret = graphql.Null
6317 }
6318 }()
6319 fc := &graphql.FieldContext{
6320 Object: "IdentityEdge",
6321 Field: field,
6322 Args: nil,
6323 IsMethod: false,
6324 }
6325
6326 ctx = graphql.WithFieldContext(ctx, fc)
6327 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6328 ctx = rctx // use context from middleware stack in children
6329 return obj.Cursor, nil
6330 })
6331 if err != nil {
6332 ec.Error(ctx, err)
6333 return graphql.Null
6334 }
6335 if resTmp == nil {
6336 if !graphql.HasFieldError(ctx, fc) {
6337 ec.Errorf(ctx, "must not be null")
6338 }
6339 return graphql.Null
6340 }
6341 res := resTmp.(string)
6342 fc.Result = res
6343 return ec.marshalNString2string(ctx, field.Selections, res)
6344}
6345
6346func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
6347 defer func() {
6348 if r := recover(); r != nil {
6349 ec.Error(ctx, ec.Recover(ctx, r))
6350 ret = graphql.Null
6351 }
6352 }()
6353 fc := &graphql.FieldContext{
6354 Object: "IdentityEdge",
6355 Field: field,
6356 Args: nil,
6357 IsMethod: false,
6358 }
6359
6360 ctx = graphql.WithFieldContext(ctx, fc)
6361 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6362 ctx = rctx // use context from middleware stack in children
6363 return obj.Node, nil
6364 })
6365 if err != nil {
6366 ec.Error(ctx, err)
6367 return graphql.Null
6368 }
6369 if resTmp == nil {
6370 if !graphql.HasFieldError(ctx, fc) {
6371 ec.Errorf(ctx, "must not be null")
6372 }
6373 return graphql.Null
6374 }
6375 res := resTmp.(models.IdentityWrapper)
6376 fc.Result = res
6377 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6378}
6379
6380func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (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: "Label",
6389 Field: field,
6390 Args: nil,
6391 IsMethod: true,
6392 }
6393
6394 ctx = graphql.WithFieldContext(ctx, fc)
6395 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6396 ctx = rctx // use context from middleware stack in children
6397 return ec.resolvers.Label().Name(rctx, obj)
6398 })
6399 if err != nil {
6400 ec.Error(ctx, err)
6401 return graphql.Null
6402 }
6403 if resTmp == nil {
6404 if !graphql.HasFieldError(ctx, fc) {
6405 ec.Errorf(ctx, "must not be null")
6406 }
6407 return graphql.Null
6408 }
6409 res := resTmp.(string)
6410 fc.Result = res
6411 return ec.marshalNString2string(ctx, field.Selections, res)
6412}
6413
6414func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (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: "Label",
6423 Field: field,
6424 Args: nil,
6425 IsMethod: true,
6426 }
6427
6428 ctx = graphql.WithFieldContext(ctx, fc)
6429 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6430 ctx = rctx // use context from middleware stack in children
6431 return ec.resolvers.Label().Color(rctx, obj)
6432 })
6433 if err != nil {
6434 ec.Error(ctx, err)
6435 return graphql.Null
6436 }
6437 if resTmp == nil {
6438 if !graphql.HasFieldError(ctx, fc) {
6439 ec.Errorf(ctx, "must not be null")
6440 }
6441 return graphql.Null
6442 }
6443 res := resTmp.(*color.RGBA)
6444 fc.Result = res
6445 return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
6446}
6447
6448func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6449 defer func() {
6450 if r := recover(); r != nil {
6451 ec.Error(ctx, ec.Recover(ctx, r))
6452 ret = graphql.Null
6453 }
6454 }()
6455 fc := &graphql.FieldContext{
6456 Object: "LabelChangeOperation",
6457 Field: field,
6458 Args: nil,
6459 IsMethod: true,
6460 }
6461
6462 ctx = graphql.WithFieldContext(ctx, fc)
6463 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6464 ctx = rctx // use context from middleware stack in children
6465 return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
6466 })
6467 if err != nil {
6468 ec.Error(ctx, err)
6469 return graphql.Null
6470 }
6471 if resTmp == nil {
6472 if !graphql.HasFieldError(ctx, fc) {
6473 ec.Errorf(ctx, "must not be null")
6474 }
6475 return graphql.Null
6476 }
6477 res := resTmp.(string)
6478 fc.Result = res
6479 return ec.marshalNString2string(ctx, field.Selections, res)
6480}
6481
6482func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6483 defer func() {
6484 if r := recover(); r != nil {
6485 ec.Error(ctx, ec.Recover(ctx, r))
6486 ret = graphql.Null
6487 }
6488 }()
6489 fc := &graphql.FieldContext{
6490 Object: "LabelChangeOperation",
6491 Field: field,
6492 Args: nil,
6493 IsMethod: true,
6494 }
6495
6496 ctx = graphql.WithFieldContext(ctx, fc)
6497 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6498 ctx = rctx // use context from middleware stack in children
6499 return ec.resolvers.LabelChangeOperation().Author(rctx, obj)
6500 })
6501 if err != nil {
6502 ec.Error(ctx, err)
6503 return graphql.Null
6504 }
6505 if resTmp == nil {
6506 if !graphql.HasFieldError(ctx, fc) {
6507 ec.Errorf(ctx, "must not be null")
6508 }
6509 return graphql.Null
6510 }
6511 res := resTmp.(models.IdentityWrapper)
6512 fc.Result = res
6513 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6514}
6515
6516func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6517 defer func() {
6518 if r := recover(); r != nil {
6519 ec.Error(ctx, ec.Recover(ctx, r))
6520 ret = graphql.Null
6521 }
6522 }()
6523 fc := &graphql.FieldContext{
6524 Object: "LabelChangeOperation",
6525 Field: field,
6526 Args: nil,
6527 IsMethod: true,
6528 }
6529
6530 ctx = graphql.WithFieldContext(ctx, fc)
6531 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6532 ctx = rctx // use context from middleware stack in children
6533 return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
6534 })
6535 if err != nil {
6536 ec.Error(ctx, err)
6537 return graphql.Null
6538 }
6539 if resTmp == nil {
6540 if !graphql.HasFieldError(ctx, fc) {
6541 ec.Errorf(ctx, "must not be null")
6542 }
6543 return graphql.Null
6544 }
6545 res := resTmp.(*time.Time)
6546 fc.Result = res
6547 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6548}
6549
6550func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6551 defer func() {
6552 if r := recover(); r != nil {
6553 ec.Error(ctx, ec.Recover(ctx, r))
6554 ret = graphql.Null
6555 }
6556 }()
6557 fc := &graphql.FieldContext{
6558 Object: "LabelChangeOperation",
6559 Field: field,
6560 Args: nil,
6561 IsMethod: false,
6562 }
6563
6564 ctx = graphql.WithFieldContext(ctx, fc)
6565 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6566 ctx = rctx // use context from middleware stack in children
6567 return obj.Added, nil
6568 })
6569 if err != nil {
6570 ec.Error(ctx, err)
6571 return graphql.Null
6572 }
6573 if resTmp == nil {
6574 if !graphql.HasFieldError(ctx, fc) {
6575 ec.Errorf(ctx, "must not be null")
6576 }
6577 return graphql.Null
6578 }
6579 res := resTmp.([]bug.Label)
6580 fc.Result = res
6581 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6582}
6583
6584func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
6585 defer func() {
6586 if r := recover(); r != nil {
6587 ec.Error(ctx, ec.Recover(ctx, r))
6588 ret = graphql.Null
6589 }
6590 }()
6591 fc := &graphql.FieldContext{
6592 Object: "LabelChangeOperation",
6593 Field: field,
6594 Args: nil,
6595 IsMethod: false,
6596 }
6597
6598 ctx = graphql.WithFieldContext(ctx, fc)
6599 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6600 ctx = rctx // use context from middleware stack in children
6601 return obj.Removed, nil
6602 })
6603 if err != nil {
6604 ec.Error(ctx, err)
6605 return graphql.Null
6606 }
6607 if resTmp == nil {
6608 if !graphql.HasFieldError(ctx, fc) {
6609 ec.Errorf(ctx, "must not be null")
6610 }
6611 return graphql.Null
6612 }
6613 res := resTmp.([]bug.Label)
6614 fc.Result = res
6615 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6616}
6617
6618func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6619 defer func() {
6620 if r := recover(); r != nil {
6621 ec.Error(ctx, ec.Recover(ctx, r))
6622 ret = graphql.Null
6623 }
6624 }()
6625 fc := &graphql.FieldContext{
6626 Object: "LabelChangeResult",
6627 Field: field,
6628 Args: nil,
6629 IsMethod: false,
6630 }
6631
6632 ctx = graphql.WithFieldContext(ctx, fc)
6633 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6634 ctx = rctx // use context from middleware stack in children
6635 return obj.Label, nil
6636 })
6637 if err != nil {
6638 ec.Error(ctx, err)
6639 return graphql.Null
6640 }
6641 if resTmp == nil {
6642 if !graphql.HasFieldError(ctx, fc) {
6643 ec.Errorf(ctx, "must not be null")
6644 }
6645 return graphql.Null
6646 }
6647 res := resTmp.(bug.Label)
6648 fc.Result = res
6649 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
6650}
6651
6652func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
6653 defer func() {
6654 if r := recover(); r != nil {
6655 ec.Error(ctx, ec.Recover(ctx, r))
6656 ret = graphql.Null
6657 }
6658 }()
6659 fc := &graphql.FieldContext{
6660 Object: "LabelChangeResult",
6661 Field: field,
6662 Args: nil,
6663 IsMethod: true,
6664 }
6665
6666 ctx = graphql.WithFieldContext(ctx, fc)
6667 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6668 ctx = rctx // use context from middleware stack in children
6669 return ec.resolvers.LabelChangeResult().Status(rctx, obj)
6670 })
6671 if err != nil {
6672 ec.Error(ctx, err)
6673 return graphql.Null
6674 }
6675 if resTmp == nil {
6676 if !graphql.HasFieldError(ctx, fc) {
6677 ec.Errorf(ctx, "must not be null")
6678 }
6679 return graphql.Null
6680 }
6681 res := resTmp.(models.LabelChangeStatus)
6682 fc.Result = res
6683 return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
6684}
6685
6686func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6687 defer func() {
6688 if r := recover(); r != nil {
6689 ec.Error(ctx, ec.Recover(ctx, r))
6690 ret = graphql.Null
6691 }
6692 }()
6693 fc := &graphql.FieldContext{
6694 Object: "LabelChangeTimelineItem",
6695 Field: field,
6696 Args: nil,
6697 IsMethod: true,
6698 }
6699
6700 ctx = graphql.WithFieldContext(ctx, fc)
6701 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6702 ctx = rctx // use context from middleware stack in children
6703 return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
6704 })
6705 if err != nil {
6706 ec.Error(ctx, err)
6707 return graphql.Null
6708 }
6709 if resTmp == nil {
6710 if !graphql.HasFieldError(ctx, fc) {
6711 ec.Errorf(ctx, "must not be null")
6712 }
6713 return graphql.Null
6714 }
6715 res := resTmp.(string)
6716 fc.Result = res
6717 return ec.marshalNString2string(ctx, field.Selections, res)
6718}
6719
6720func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6721 defer func() {
6722 if r := recover(); r != nil {
6723 ec.Error(ctx, ec.Recover(ctx, r))
6724 ret = graphql.Null
6725 }
6726 }()
6727 fc := &graphql.FieldContext{
6728 Object: "LabelChangeTimelineItem",
6729 Field: field,
6730 Args: nil,
6731 IsMethod: true,
6732 }
6733
6734 ctx = graphql.WithFieldContext(ctx, fc)
6735 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6736 ctx = rctx // use context from middleware stack in children
6737 return ec.resolvers.LabelChangeTimelineItem().Author(rctx, obj)
6738 })
6739 if err != nil {
6740 ec.Error(ctx, err)
6741 return graphql.Null
6742 }
6743 if resTmp == nil {
6744 if !graphql.HasFieldError(ctx, fc) {
6745 ec.Errorf(ctx, "must not be null")
6746 }
6747 return graphql.Null
6748 }
6749 res := resTmp.(models.IdentityWrapper)
6750 fc.Result = res
6751 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
6752}
6753
6754func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6755 defer func() {
6756 if r := recover(); r != nil {
6757 ec.Error(ctx, ec.Recover(ctx, r))
6758 ret = graphql.Null
6759 }
6760 }()
6761 fc := &graphql.FieldContext{
6762 Object: "LabelChangeTimelineItem",
6763 Field: field,
6764 Args: nil,
6765 IsMethod: true,
6766 }
6767
6768 ctx = graphql.WithFieldContext(ctx, fc)
6769 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6770 ctx = rctx // use context from middleware stack in children
6771 return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
6772 })
6773 if err != nil {
6774 ec.Error(ctx, err)
6775 return graphql.Null
6776 }
6777 if resTmp == nil {
6778 if !graphql.HasFieldError(ctx, fc) {
6779 ec.Errorf(ctx, "must not be null")
6780 }
6781 return graphql.Null
6782 }
6783 res := resTmp.(*time.Time)
6784 fc.Result = res
6785 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
6786}
6787
6788func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6789 defer func() {
6790 if r := recover(); r != nil {
6791 ec.Error(ctx, ec.Recover(ctx, r))
6792 ret = graphql.Null
6793 }
6794 }()
6795 fc := &graphql.FieldContext{
6796 Object: "LabelChangeTimelineItem",
6797 Field: field,
6798 Args: nil,
6799 IsMethod: false,
6800 }
6801
6802 ctx = graphql.WithFieldContext(ctx, fc)
6803 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6804 ctx = rctx // use context from middleware stack in children
6805 return obj.Added, nil
6806 })
6807 if err != nil {
6808 ec.Error(ctx, err)
6809 return graphql.Null
6810 }
6811 if resTmp == nil {
6812 if !graphql.HasFieldError(ctx, fc) {
6813 ec.Errorf(ctx, "must not be null")
6814 }
6815 return graphql.Null
6816 }
6817 res := resTmp.([]bug.Label)
6818 fc.Result = res
6819 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6820}
6821
6822func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
6823 defer func() {
6824 if r := recover(); r != nil {
6825 ec.Error(ctx, ec.Recover(ctx, r))
6826 ret = graphql.Null
6827 }
6828 }()
6829 fc := &graphql.FieldContext{
6830 Object: "LabelChangeTimelineItem",
6831 Field: field,
6832 Args: nil,
6833 IsMethod: false,
6834 }
6835
6836 ctx = graphql.WithFieldContext(ctx, fc)
6837 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6838 ctx = rctx // use context from middleware stack in children
6839 return obj.Removed, nil
6840 })
6841 if err != nil {
6842 ec.Error(ctx, err)
6843 return graphql.Null
6844 }
6845 if resTmp == nil {
6846 if !graphql.HasFieldError(ctx, fc) {
6847 ec.Errorf(ctx, "must not be null")
6848 }
6849 return graphql.Null
6850 }
6851 res := resTmp.([]bug.Label)
6852 fc.Result = res
6853 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6854}
6855
6856func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
6857 defer func() {
6858 if r := recover(); r != nil {
6859 ec.Error(ctx, ec.Recover(ctx, r))
6860 ret = graphql.Null
6861 }
6862 }()
6863 fc := &graphql.FieldContext{
6864 Object: "LabelConnection",
6865 Field: field,
6866 Args: nil,
6867 IsMethod: false,
6868 }
6869
6870 ctx = graphql.WithFieldContext(ctx, fc)
6871 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6872 ctx = rctx // use context from middleware stack in children
6873 return obj.Edges, nil
6874 })
6875 if err != nil {
6876 ec.Error(ctx, err)
6877 return graphql.Null
6878 }
6879 if resTmp == nil {
6880 if !graphql.HasFieldError(ctx, fc) {
6881 ec.Errorf(ctx, "must not be null")
6882 }
6883 return graphql.Null
6884 }
6885 res := resTmp.([]*models.LabelEdge)
6886 fc.Result = res
6887 return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx, field.Selections, res)
6888}
6889
6890func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
6891 defer func() {
6892 if r := recover(); r != nil {
6893 ec.Error(ctx, ec.Recover(ctx, r))
6894 ret = graphql.Null
6895 }
6896 }()
6897 fc := &graphql.FieldContext{
6898 Object: "LabelConnection",
6899 Field: field,
6900 Args: nil,
6901 IsMethod: false,
6902 }
6903
6904 ctx = graphql.WithFieldContext(ctx, fc)
6905 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6906 ctx = rctx // use context from middleware stack in children
6907 return obj.Nodes, nil
6908 })
6909 if err != nil {
6910 ec.Error(ctx, err)
6911 return graphql.Null
6912 }
6913 if resTmp == nil {
6914 if !graphql.HasFieldError(ctx, fc) {
6915 ec.Errorf(ctx, "must not be null")
6916 }
6917 return graphql.Null
6918 }
6919 res := resTmp.([]bug.Label)
6920 fc.Result = res
6921 return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
6922}
6923
6924func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
6925 defer func() {
6926 if r := recover(); r != nil {
6927 ec.Error(ctx, ec.Recover(ctx, r))
6928 ret = graphql.Null
6929 }
6930 }()
6931 fc := &graphql.FieldContext{
6932 Object: "LabelConnection",
6933 Field: field,
6934 Args: nil,
6935 IsMethod: false,
6936 }
6937
6938 ctx = graphql.WithFieldContext(ctx, fc)
6939 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6940 ctx = rctx // use context from middleware stack in children
6941 return obj.PageInfo, nil
6942 })
6943 if err != nil {
6944 ec.Error(ctx, err)
6945 return graphql.Null
6946 }
6947 if resTmp == nil {
6948 if !graphql.HasFieldError(ctx, fc) {
6949 ec.Errorf(ctx, "must not be null")
6950 }
6951 return graphql.Null
6952 }
6953 res := resTmp.(*models.PageInfo)
6954 fc.Result = res
6955 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
6956}
6957
6958func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
6959 defer func() {
6960 if r := recover(); r != nil {
6961 ec.Error(ctx, ec.Recover(ctx, r))
6962 ret = graphql.Null
6963 }
6964 }()
6965 fc := &graphql.FieldContext{
6966 Object: "LabelConnection",
6967 Field: field,
6968 Args: nil,
6969 IsMethod: false,
6970 }
6971
6972 ctx = graphql.WithFieldContext(ctx, fc)
6973 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
6974 ctx = rctx // use context from middleware stack in children
6975 return obj.TotalCount, nil
6976 })
6977 if err != nil {
6978 ec.Error(ctx, err)
6979 return graphql.Null
6980 }
6981 if resTmp == nil {
6982 if !graphql.HasFieldError(ctx, fc) {
6983 ec.Errorf(ctx, "must not be null")
6984 }
6985 return graphql.Null
6986 }
6987 res := resTmp.(int)
6988 fc.Result = res
6989 return ec.marshalNInt2int(ctx, field.Selections, res)
6990}
6991
6992func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
6993 defer func() {
6994 if r := recover(); r != nil {
6995 ec.Error(ctx, ec.Recover(ctx, r))
6996 ret = graphql.Null
6997 }
6998 }()
6999 fc := &graphql.FieldContext{
7000 Object: "LabelEdge",
7001 Field: field,
7002 Args: nil,
7003 IsMethod: false,
7004 }
7005
7006 ctx = graphql.WithFieldContext(ctx, fc)
7007 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7008 ctx = rctx // use context from middleware stack in children
7009 return obj.Cursor, nil
7010 })
7011 if err != nil {
7012 ec.Error(ctx, err)
7013 return graphql.Null
7014 }
7015 if resTmp == nil {
7016 if !graphql.HasFieldError(ctx, fc) {
7017 ec.Errorf(ctx, "must not be null")
7018 }
7019 return graphql.Null
7020 }
7021 res := resTmp.(string)
7022 fc.Result = res
7023 return ec.marshalNString2string(ctx, field.Selections, res)
7024}
7025
7026func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
7027 defer func() {
7028 if r := recover(); r != nil {
7029 ec.Error(ctx, ec.Recover(ctx, r))
7030 ret = graphql.Null
7031 }
7032 }()
7033 fc := &graphql.FieldContext{
7034 Object: "LabelEdge",
7035 Field: field,
7036 Args: nil,
7037 IsMethod: false,
7038 }
7039
7040 ctx = graphql.WithFieldContext(ctx, fc)
7041 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7042 ctx = rctx // use context from middleware stack in children
7043 return obj.Node, nil
7044 })
7045 if err != nil {
7046 ec.Error(ctx, err)
7047 return graphql.Null
7048 }
7049 if resTmp == nil {
7050 if !graphql.HasFieldError(ctx, fc) {
7051 ec.Errorf(ctx, "must not be null")
7052 }
7053 return graphql.Null
7054 }
7055 res := resTmp.(bug.Label)
7056 fc.Result = res
7057 return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
7058}
7059
7060func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7061 defer func() {
7062 if r := recover(); r != nil {
7063 ec.Error(ctx, ec.Recover(ctx, r))
7064 ret = graphql.Null
7065 }
7066 }()
7067 fc := &graphql.FieldContext{
7068 Object: "Mutation",
7069 Field: field,
7070 Args: nil,
7071 IsMethod: true,
7072 }
7073
7074 ctx = graphql.WithFieldContext(ctx, fc)
7075 rawArgs := field.ArgumentMap(ec.Variables)
7076 args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
7077 if err != nil {
7078 ec.Error(ctx, err)
7079 return graphql.Null
7080 }
7081 fc.Args = args
7082 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7083 ctx = rctx // use context from middleware stack in children
7084 return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput), args["txId"].(*string))
7085 })
7086 if err != nil {
7087 ec.Error(ctx, err)
7088 return graphql.Null
7089 }
7090 if resTmp == nil {
7091 if !graphql.HasFieldError(ctx, fc) {
7092 ec.Errorf(ctx, "must not be null")
7093 }
7094 return graphql.Null
7095 }
7096 res := resTmp.(*models.NewBugPayload)
7097 fc.Result = res
7098 return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
7099}
7100
7101func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7102 defer func() {
7103 if r := recover(); r != nil {
7104 ec.Error(ctx, ec.Recover(ctx, r))
7105 ret = graphql.Null
7106 }
7107 }()
7108 fc := &graphql.FieldContext{
7109 Object: "Mutation",
7110 Field: field,
7111 Args: nil,
7112 IsMethod: true,
7113 }
7114
7115 ctx = graphql.WithFieldContext(ctx, fc)
7116 rawArgs := field.ArgumentMap(ec.Variables)
7117 args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
7118 if err != nil {
7119 ec.Error(ctx, err)
7120 return graphql.Null
7121 }
7122 fc.Args = args
7123 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7124 ctx = rctx // use context from middleware stack in children
7125 return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput), args["txId"].(*string))
7126 })
7127 if err != nil {
7128 ec.Error(ctx, err)
7129 return graphql.Null
7130 }
7131 if resTmp == nil {
7132 if !graphql.HasFieldError(ctx, fc) {
7133 ec.Errorf(ctx, "must not be null")
7134 }
7135 return graphql.Null
7136 }
7137 res := resTmp.(*models.AddCommentPayload)
7138 fc.Result = res
7139 return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
7140}
7141
7142func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7143 defer func() {
7144 if r := recover(); r != nil {
7145 ec.Error(ctx, ec.Recover(ctx, r))
7146 ret = graphql.Null
7147 }
7148 }()
7149 fc := &graphql.FieldContext{
7150 Object: "Mutation",
7151 Field: field,
7152 Args: nil,
7153 IsMethod: true,
7154 }
7155
7156 ctx = graphql.WithFieldContext(ctx, fc)
7157 rawArgs := field.ArgumentMap(ec.Variables)
7158 args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
7159 if err != nil {
7160 ec.Error(ctx, err)
7161 return graphql.Null
7162 }
7163 fc.Args = args
7164 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7165 ctx = rctx // use context from middleware stack in children
7166 return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(models.ChangeLabelInput), args["txId"].(*string))
7167 })
7168 if err != nil {
7169 ec.Error(ctx, err)
7170 return graphql.Null
7171 }
7172 if resTmp == nil {
7173 if !graphql.HasFieldError(ctx, fc) {
7174 ec.Errorf(ctx, "must not be null")
7175 }
7176 return graphql.Null
7177 }
7178 res := resTmp.(*models.ChangeLabelPayload)
7179 fc.Result = res
7180 return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
7181}
7182
7183func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7184 defer func() {
7185 if r := recover(); r != nil {
7186 ec.Error(ctx, ec.Recover(ctx, r))
7187 ret = graphql.Null
7188 }
7189 }()
7190 fc := &graphql.FieldContext{
7191 Object: "Mutation",
7192 Field: field,
7193 Args: nil,
7194 IsMethod: true,
7195 }
7196
7197 ctx = graphql.WithFieldContext(ctx, fc)
7198 rawArgs := field.ArgumentMap(ec.Variables)
7199 args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
7200 if err != nil {
7201 ec.Error(ctx, err)
7202 return graphql.Null
7203 }
7204 fc.Args = args
7205 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7206 ctx = rctx // use context from middleware stack in children
7207 return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput), args["txId"].(*string))
7208 })
7209 if err != nil {
7210 ec.Error(ctx, err)
7211 return graphql.Null
7212 }
7213 if resTmp == nil {
7214 if !graphql.HasFieldError(ctx, fc) {
7215 ec.Errorf(ctx, "must not be null")
7216 }
7217 return graphql.Null
7218 }
7219 res := resTmp.(*models.OpenBugPayload)
7220 fc.Result = res
7221 return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
7222}
7223
7224func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7225 defer func() {
7226 if r := recover(); r != nil {
7227 ec.Error(ctx, ec.Recover(ctx, r))
7228 ret = graphql.Null
7229 }
7230 }()
7231 fc := &graphql.FieldContext{
7232 Object: "Mutation",
7233 Field: field,
7234 Args: nil,
7235 IsMethod: true,
7236 }
7237
7238 ctx = graphql.WithFieldContext(ctx, fc)
7239 rawArgs := field.ArgumentMap(ec.Variables)
7240 args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
7241 if err != nil {
7242 ec.Error(ctx, err)
7243 return graphql.Null
7244 }
7245 fc.Args = args
7246 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7247 ctx = rctx // use context from middleware stack in children
7248 return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput), args["txId"].(*string))
7249 })
7250 if err != nil {
7251 ec.Error(ctx, err)
7252 return graphql.Null
7253 }
7254 if resTmp == nil {
7255 if !graphql.HasFieldError(ctx, fc) {
7256 ec.Errorf(ctx, "must not be null")
7257 }
7258 return graphql.Null
7259 }
7260 res := resTmp.(*models.CloseBugPayload)
7261 fc.Result = res
7262 return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
7263}
7264
7265func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7266 defer func() {
7267 if r := recover(); r != nil {
7268 ec.Error(ctx, ec.Recover(ctx, r))
7269 ret = graphql.Null
7270 }
7271 }()
7272 fc := &graphql.FieldContext{
7273 Object: "Mutation",
7274 Field: field,
7275 Args: nil,
7276 IsMethod: true,
7277 }
7278
7279 ctx = graphql.WithFieldContext(ctx, fc)
7280 rawArgs := field.ArgumentMap(ec.Variables)
7281 args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
7282 if err != nil {
7283 ec.Error(ctx, err)
7284 return graphql.Null
7285 }
7286 fc.Args = args
7287 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7288 ctx = rctx // use context from middleware stack in children
7289 return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput), args["txId"].(*string))
7290 })
7291 if err != nil {
7292 ec.Error(ctx, err)
7293 return graphql.Null
7294 }
7295 if resTmp == nil {
7296 if !graphql.HasFieldError(ctx, fc) {
7297 ec.Errorf(ctx, "must not be null")
7298 }
7299 return graphql.Null
7300 }
7301 res := resTmp.(*models.SetTitlePayload)
7302 fc.Result = res
7303 return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
7304}
7305
7306func (ec *executionContext) _Mutation_startTransaction(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7307 defer func() {
7308 if r := recover(); r != nil {
7309 ec.Error(ctx, ec.Recover(ctx, r))
7310 ret = graphql.Null
7311 }
7312 }()
7313 fc := &graphql.FieldContext{
7314 Object: "Mutation",
7315 Field: field,
7316 Args: nil,
7317 IsMethod: true,
7318 }
7319
7320 ctx = graphql.WithFieldContext(ctx, fc)
7321 rawArgs := field.ArgumentMap(ec.Variables)
7322 args, err := ec.field_Mutation_startTransaction_args(ctx, rawArgs)
7323 if err != nil {
7324 ec.Error(ctx, err)
7325 return graphql.Null
7326 }
7327 fc.Args = args
7328 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7329 ctx = rctx // use context from middleware stack in children
7330 return ec.resolvers.Mutation().StartTransaction(rctx, args["input"].(models.StartTransactionInput))
7331 })
7332 if err != nil {
7333 ec.Error(ctx, err)
7334 return graphql.Null
7335 }
7336 if resTmp == nil {
7337 if !graphql.HasFieldError(ctx, fc) {
7338 ec.Errorf(ctx, "must not be null")
7339 }
7340 return graphql.Null
7341 }
7342 res := resTmp.(*models.StartTransactionPayload)
7343 fc.Result = res
7344 return ec.marshalNStartTransactionPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStartTransactionPayload(ctx, field.Selections, res)
7345}
7346
7347func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7348 defer func() {
7349 if r := recover(); r != nil {
7350 ec.Error(ctx, ec.Recover(ctx, r))
7351 ret = graphql.Null
7352 }
7353 }()
7354 fc := &graphql.FieldContext{
7355 Object: "Mutation",
7356 Field: field,
7357 Args: nil,
7358 IsMethod: true,
7359 }
7360
7361 ctx = graphql.WithFieldContext(ctx, fc)
7362 rawArgs := field.ArgumentMap(ec.Variables)
7363 args, err := ec.field_Mutation_commit_args(ctx, rawArgs)
7364 if err != nil {
7365 ec.Error(ctx, err)
7366 return graphql.Null
7367 }
7368 fc.Args = args
7369 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7370 ctx = rctx // use context from middleware stack in children
7371 return ec.resolvers.Mutation().Commit(rctx, args["input"].(models.CommitInput))
7372 })
7373 if err != nil {
7374 ec.Error(ctx, err)
7375 return graphql.Null
7376 }
7377 if resTmp == nil {
7378 if !graphql.HasFieldError(ctx, fc) {
7379 ec.Errorf(ctx, "must not be null")
7380 }
7381 return graphql.Null
7382 }
7383 res := resTmp.(*models.CommitPayload)
7384 fc.Result = res
7385 return ec.marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx, field.Selections, res)
7386}
7387
7388func (ec *executionContext) _Mutation_rollback(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7389 defer func() {
7390 if r := recover(); r != nil {
7391 ec.Error(ctx, ec.Recover(ctx, r))
7392 ret = graphql.Null
7393 }
7394 }()
7395 fc := &graphql.FieldContext{
7396 Object: "Mutation",
7397 Field: field,
7398 Args: nil,
7399 IsMethod: true,
7400 }
7401
7402 ctx = graphql.WithFieldContext(ctx, fc)
7403 rawArgs := field.ArgumentMap(ec.Variables)
7404 args, err := ec.field_Mutation_rollback_args(ctx, rawArgs)
7405 if err != nil {
7406 ec.Error(ctx, err)
7407 return graphql.Null
7408 }
7409 fc.Args = args
7410 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7411 ctx = rctx // use context from middleware stack in children
7412 return ec.resolvers.Mutation().Rollback(rctx, args["input"].(models.RollbackInput))
7413 })
7414 if err != nil {
7415 ec.Error(ctx, err)
7416 return graphql.Null
7417 }
7418 if resTmp == nil {
7419 if !graphql.HasFieldError(ctx, fc) {
7420 ec.Errorf(ctx, "must not be null")
7421 }
7422 return graphql.Null
7423 }
7424 res := resTmp.(*models.RollbackPayload)
7425 fc.Result = res
7426 return ec.marshalNRollbackPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRollbackPayload(ctx, field.Selections, res)
7427}
7428
7429func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7430 defer func() {
7431 if r := recover(); r != nil {
7432 ec.Error(ctx, ec.Recover(ctx, r))
7433 ret = graphql.Null
7434 }
7435 }()
7436 fc := &graphql.FieldContext{
7437 Object: "NewBugPayload",
7438 Field: field,
7439 Args: nil,
7440 IsMethod: false,
7441 }
7442
7443 ctx = graphql.WithFieldContext(ctx, fc)
7444 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7445 ctx = rctx // use context from middleware stack in children
7446 return obj.ClientMutationID, nil
7447 })
7448 if err != nil {
7449 ec.Error(ctx, err)
7450 return graphql.Null
7451 }
7452 if resTmp == nil {
7453 return graphql.Null
7454 }
7455 res := resTmp.(*string)
7456 fc.Result = res
7457 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7458}
7459
7460func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7461 defer func() {
7462 if r := recover(); r != nil {
7463 ec.Error(ctx, ec.Recover(ctx, r))
7464 ret = graphql.Null
7465 }
7466 }()
7467 fc := &graphql.FieldContext{
7468 Object: "NewBugPayload",
7469 Field: field,
7470 Args: nil,
7471 IsMethod: false,
7472 }
7473
7474 ctx = graphql.WithFieldContext(ctx, fc)
7475 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7476 ctx = rctx // use context from middleware stack in children
7477 return obj.Bug, nil
7478 })
7479 if err != nil {
7480 ec.Error(ctx, err)
7481 return graphql.Null
7482 }
7483 if resTmp == nil {
7484 if !graphql.HasFieldError(ctx, fc) {
7485 ec.Errorf(ctx, "must not be null")
7486 }
7487 return graphql.Null
7488 }
7489 res := resTmp.(models.BugWrapper)
7490 fc.Result = res
7491 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
7492}
7493
7494func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
7495 defer func() {
7496 if r := recover(); r != nil {
7497 ec.Error(ctx, ec.Recover(ctx, r))
7498 ret = graphql.Null
7499 }
7500 }()
7501 fc := &graphql.FieldContext{
7502 Object: "NewBugPayload",
7503 Field: field,
7504 Args: nil,
7505 IsMethod: false,
7506 }
7507
7508 ctx = graphql.WithFieldContext(ctx, fc)
7509 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7510 ctx = rctx // use context from middleware stack in children
7511 return obj.Operation, nil
7512 })
7513 if err != nil {
7514 ec.Error(ctx, err)
7515 return graphql.Null
7516 }
7517 if resTmp == nil {
7518 if !graphql.HasFieldError(ctx, fc) {
7519 ec.Errorf(ctx, "must not be null")
7520 }
7521 return graphql.Null
7522 }
7523 res := resTmp.(*bug.CreateOperation)
7524 fc.Result = res
7525 return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
7526}
7527
7528func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7529 defer func() {
7530 if r := recover(); r != nil {
7531 ec.Error(ctx, ec.Recover(ctx, r))
7532 ret = graphql.Null
7533 }
7534 }()
7535 fc := &graphql.FieldContext{
7536 Object: "OpenBugPayload",
7537 Field: field,
7538 Args: nil,
7539 IsMethod: false,
7540 }
7541
7542 ctx = graphql.WithFieldContext(ctx, fc)
7543 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7544 ctx = rctx // use context from middleware stack in children
7545 return obj.ClientMutationID, nil
7546 })
7547 if err != nil {
7548 ec.Error(ctx, err)
7549 return graphql.Null
7550 }
7551 if resTmp == nil {
7552 return graphql.Null
7553 }
7554 res := resTmp.(*string)
7555 fc.Result = res
7556 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
7557}
7558
7559func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7560 defer func() {
7561 if r := recover(); r != nil {
7562 ec.Error(ctx, ec.Recover(ctx, r))
7563 ret = graphql.Null
7564 }
7565 }()
7566 fc := &graphql.FieldContext{
7567 Object: "OpenBugPayload",
7568 Field: field,
7569 Args: nil,
7570 IsMethod: false,
7571 }
7572
7573 ctx = graphql.WithFieldContext(ctx, fc)
7574 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7575 ctx = rctx // use context from middleware stack in children
7576 return obj.Bug, nil
7577 })
7578 if err != nil {
7579 ec.Error(ctx, err)
7580 return graphql.Null
7581 }
7582 if resTmp == nil {
7583 if !graphql.HasFieldError(ctx, fc) {
7584 ec.Errorf(ctx, "must not be null")
7585 }
7586 return graphql.Null
7587 }
7588 res := resTmp.(models.BugWrapper)
7589 fc.Result = res
7590 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
7591}
7592
7593func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
7594 defer func() {
7595 if r := recover(); r != nil {
7596 ec.Error(ctx, ec.Recover(ctx, r))
7597 ret = graphql.Null
7598 }
7599 }()
7600 fc := &graphql.FieldContext{
7601 Object: "OpenBugPayload",
7602 Field: field,
7603 Args: nil,
7604 IsMethod: false,
7605 }
7606
7607 ctx = graphql.WithFieldContext(ctx, fc)
7608 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7609 ctx = rctx // use context from middleware stack in children
7610 return obj.Operation, nil
7611 })
7612 if err != nil {
7613 ec.Error(ctx, err)
7614 return graphql.Null
7615 }
7616 if resTmp == nil {
7617 if !graphql.HasFieldError(ctx, fc) {
7618 ec.Errorf(ctx, "must not be null")
7619 }
7620 return graphql.Null
7621 }
7622 res := resTmp.(*bug.SetStatusOperation)
7623 fc.Result = res
7624 return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
7625}
7626
7627func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7628 defer func() {
7629 if r := recover(); r != nil {
7630 ec.Error(ctx, ec.Recover(ctx, r))
7631 ret = graphql.Null
7632 }
7633 }()
7634 fc := &graphql.FieldContext{
7635 Object: "OperationConnection",
7636 Field: field,
7637 Args: nil,
7638 IsMethod: false,
7639 }
7640
7641 ctx = graphql.WithFieldContext(ctx, fc)
7642 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7643 ctx = rctx // use context from middleware stack in children
7644 return obj.Edges, nil
7645 })
7646 if err != nil {
7647 ec.Error(ctx, err)
7648 return graphql.Null
7649 }
7650 if resTmp == nil {
7651 if !graphql.HasFieldError(ctx, fc) {
7652 ec.Errorf(ctx, "must not be null")
7653 }
7654 return graphql.Null
7655 }
7656 res := resTmp.([]*models.OperationEdge)
7657 fc.Result = res
7658 return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
7659}
7660
7661func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7662 defer func() {
7663 if r := recover(); r != nil {
7664 ec.Error(ctx, ec.Recover(ctx, r))
7665 ret = graphql.Null
7666 }
7667 }()
7668 fc := &graphql.FieldContext{
7669 Object: "OperationConnection",
7670 Field: field,
7671 Args: nil,
7672 IsMethod: false,
7673 }
7674
7675 ctx = graphql.WithFieldContext(ctx, fc)
7676 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7677 ctx = rctx // use context from middleware stack in children
7678 return obj.Nodes, nil
7679 })
7680 if err != nil {
7681 ec.Error(ctx, err)
7682 return graphql.Null
7683 }
7684 if resTmp == nil {
7685 if !graphql.HasFieldError(ctx, fc) {
7686 ec.Errorf(ctx, "must not be null")
7687 }
7688 return graphql.Null
7689 }
7690 res := resTmp.([]bug.Operation)
7691 fc.Result = res
7692 return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx, field.Selections, res)
7693}
7694
7695func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7696 defer func() {
7697 if r := recover(); r != nil {
7698 ec.Error(ctx, ec.Recover(ctx, r))
7699 ret = graphql.Null
7700 }
7701 }()
7702 fc := &graphql.FieldContext{
7703 Object: "OperationConnection",
7704 Field: field,
7705 Args: nil,
7706 IsMethod: false,
7707 }
7708
7709 ctx = graphql.WithFieldContext(ctx, fc)
7710 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7711 ctx = rctx // use context from middleware stack in children
7712 return obj.PageInfo, nil
7713 })
7714 if err != nil {
7715 ec.Error(ctx, err)
7716 return graphql.Null
7717 }
7718 if resTmp == nil {
7719 if !graphql.HasFieldError(ctx, fc) {
7720 ec.Errorf(ctx, "must not be null")
7721 }
7722 return graphql.Null
7723 }
7724 res := resTmp.(*models.PageInfo)
7725 fc.Result = res
7726 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
7727}
7728
7729func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
7730 defer func() {
7731 if r := recover(); r != nil {
7732 ec.Error(ctx, ec.Recover(ctx, r))
7733 ret = graphql.Null
7734 }
7735 }()
7736 fc := &graphql.FieldContext{
7737 Object: "OperationConnection",
7738 Field: field,
7739 Args: nil,
7740 IsMethod: false,
7741 }
7742
7743 ctx = graphql.WithFieldContext(ctx, fc)
7744 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7745 ctx = rctx // use context from middleware stack in children
7746 return obj.TotalCount, nil
7747 })
7748 if err != nil {
7749 ec.Error(ctx, err)
7750 return graphql.Null
7751 }
7752 if resTmp == nil {
7753 if !graphql.HasFieldError(ctx, fc) {
7754 ec.Errorf(ctx, "must not be null")
7755 }
7756 return graphql.Null
7757 }
7758 res := resTmp.(int)
7759 fc.Result = res
7760 return ec.marshalNInt2int(ctx, field.Selections, res)
7761}
7762
7763func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (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: "OperationEdge",
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.Cursor, 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.(string)
7793 fc.Result = res
7794 return ec.marshalNString2string(ctx, field.Selections, res)
7795}
7796
7797func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (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: "OperationEdge",
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.Node, 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.Operation)
7827 fc.Result = res
7828 return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
7829}
7830
7831func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (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: "PageInfo",
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.HasNextPage, nil
7849 })
7850 if err != nil {
7851 ec.Error(ctx, err)
7852 return graphql.Null
7853 }
7854 if resTmp == nil {
7855 if !graphql.HasFieldError(ctx, fc) {
7856 ec.Errorf(ctx, "must not be null")
7857 }
7858 return graphql.Null
7859 }
7860 res := resTmp.(bool)
7861 fc.Result = res
7862 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
7863}
7864
7865func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7866 defer func() {
7867 if r := recover(); r != nil {
7868 ec.Error(ctx, ec.Recover(ctx, r))
7869 ret = graphql.Null
7870 }
7871 }()
7872 fc := &graphql.FieldContext{
7873 Object: "PageInfo",
7874 Field: field,
7875 Args: nil,
7876 IsMethod: false,
7877 }
7878
7879 ctx = graphql.WithFieldContext(ctx, fc)
7880 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7881 ctx = rctx // use context from middleware stack in children
7882 return obj.HasPreviousPage, nil
7883 })
7884 if err != nil {
7885 ec.Error(ctx, err)
7886 return graphql.Null
7887 }
7888 if resTmp == nil {
7889 if !graphql.HasFieldError(ctx, fc) {
7890 ec.Errorf(ctx, "must not be null")
7891 }
7892 return graphql.Null
7893 }
7894 res := resTmp.(bool)
7895 fc.Result = res
7896 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
7897}
7898
7899func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7900 defer func() {
7901 if r := recover(); r != nil {
7902 ec.Error(ctx, ec.Recover(ctx, r))
7903 ret = graphql.Null
7904 }
7905 }()
7906 fc := &graphql.FieldContext{
7907 Object: "PageInfo",
7908 Field: field,
7909 Args: nil,
7910 IsMethod: false,
7911 }
7912
7913 ctx = graphql.WithFieldContext(ctx, fc)
7914 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7915 ctx = rctx // use context from middleware stack in children
7916 return obj.StartCursor, nil
7917 })
7918 if err != nil {
7919 ec.Error(ctx, err)
7920 return graphql.Null
7921 }
7922 if resTmp == nil {
7923 if !graphql.HasFieldError(ctx, fc) {
7924 ec.Errorf(ctx, "must not be null")
7925 }
7926 return graphql.Null
7927 }
7928 res := resTmp.(string)
7929 fc.Result = res
7930 return ec.marshalNString2string(ctx, field.Selections, res)
7931}
7932
7933func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
7934 defer func() {
7935 if r := recover(); r != nil {
7936 ec.Error(ctx, ec.Recover(ctx, r))
7937 ret = graphql.Null
7938 }
7939 }()
7940 fc := &graphql.FieldContext{
7941 Object: "PageInfo",
7942 Field: field,
7943 Args: nil,
7944 IsMethod: false,
7945 }
7946
7947 ctx = graphql.WithFieldContext(ctx, fc)
7948 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7949 ctx = rctx // use context from middleware stack in children
7950 return obj.EndCursor, nil
7951 })
7952 if err != nil {
7953 ec.Error(ctx, err)
7954 return graphql.Null
7955 }
7956 if resTmp == nil {
7957 if !graphql.HasFieldError(ctx, fc) {
7958 ec.Errorf(ctx, "must not be null")
7959 }
7960 return graphql.Null
7961 }
7962 res := resTmp.(string)
7963 fc.Result = res
7964 return ec.marshalNString2string(ctx, field.Selections, res)
7965}
7966
7967func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
7968 defer func() {
7969 if r := recover(); r != nil {
7970 ec.Error(ctx, ec.Recover(ctx, r))
7971 ret = graphql.Null
7972 }
7973 }()
7974 fc := &graphql.FieldContext{
7975 Object: "Query",
7976 Field: field,
7977 Args: nil,
7978 IsMethod: true,
7979 }
7980
7981 ctx = graphql.WithFieldContext(ctx, fc)
7982 rawArgs := field.ArgumentMap(ec.Variables)
7983 args, err := ec.field_Query_repository_args(ctx, rawArgs)
7984 if err != nil {
7985 ec.Error(ctx, err)
7986 return graphql.Null
7987 }
7988 fc.Args = args
7989 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
7990 ctx = rctx // use context from middleware stack in children
7991 return ec.resolvers.Query().Repository(rctx, args["ref"].(*string))
7992 })
7993 if err != nil {
7994 ec.Error(ctx, err)
7995 return graphql.Null
7996 }
7997 if resTmp == nil {
7998 return graphql.Null
7999 }
8000 res := resTmp.(*models.Repository)
8001 fc.Result = res
8002 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
8003}
8004
8005func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8006 defer func() {
8007 if r := recover(); r != nil {
8008 ec.Error(ctx, ec.Recover(ctx, r))
8009 ret = graphql.Null
8010 }
8011 }()
8012 fc := &graphql.FieldContext{
8013 Object: "Query",
8014 Field: field,
8015 Args: nil,
8016 IsMethod: true,
8017 }
8018
8019 ctx = graphql.WithFieldContext(ctx, fc)
8020 rawArgs := field.ArgumentMap(ec.Variables)
8021 args, err := ec.field_Query___type_args(ctx, rawArgs)
8022 if err != nil {
8023 ec.Error(ctx, err)
8024 return graphql.Null
8025 }
8026 fc.Args = args
8027 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8028 ctx = rctx // use context from middleware stack in children
8029 return ec.introspectType(args["name"].(string))
8030 })
8031 if err != nil {
8032 ec.Error(ctx, err)
8033 return graphql.Null
8034 }
8035 if resTmp == nil {
8036 return graphql.Null
8037 }
8038 res := resTmp.(*introspection.Type)
8039 fc.Result = res
8040 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
8041}
8042
8043func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8044 defer func() {
8045 if r := recover(); r != nil {
8046 ec.Error(ctx, ec.Recover(ctx, r))
8047 ret = graphql.Null
8048 }
8049 }()
8050 fc := &graphql.FieldContext{
8051 Object: "Query",
8052 Field: field,
8053 Args: nil,
8054 IsMethod: true,
8055 }
8056
8057 ctx = graphql.WithFieldContext(ctx, fc)
8058 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8059 ctx = rctx // use context from middleware stack in children
8060 return ec.introspectSchema()
8061 })
8062 if err != nil {
8063 ec.Error(ctx, err)
8064 return graphql.Null
8065 }
8066 if resTmp == nil {
8067 return graphql.Null
8068 }
8069 res := resTmp.(*introspection.Schema)
8070 fc.Result = res
8071 return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
8072}
8073
8074func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8075 defer func() {
8076 if r := recover(); r != nil {
8077 ec.Error(ctx, ec.Recover(ctx, r))
8078 ret = graphql.Null
8079 }
8080 }()
8081 fc := &graphql.FieldContext{
8082 Object: "Repository",
8083 Field: field,
8084 Args: nil,
8085 IsMethod: true,
8086 }
8087
8088 ctx = graphql.WithFieldContext(ctx, fc)
8089 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8090 ctx = rctx // use context from middleware stack in children
8091 return ec.resolvers.Repository().Name(rctx, obj)
8092 })
8093 if err != nil {
8094 ec.Error(ctx, err)
8095 return graphql.Null
8096 }
8097 if resTmp == nil {
8098 return graphql.Null
8099 }
8100 res := resTmp.(*string)
8101 fc.Result = res
8102 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
8103}
8104
8105func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8106 defer func() {
8107 if r := recover(); r != nil {
8108 ec.Error(ctx, ec.Recover(ctx, r))
8109 ret = graphql.Null
8110 }
8111 }()
8112 fc := &graphql.FieldContext{
8113 Object: "Repository",
8114 Field: field,
8115 Args: nil,
8116 IsMethod: true,
8117 }
8118
8119 ctx = graphql.WithFieldContext(ctx, fc)
8120 rawArgs := field.ArgumentMap(ec.Variables)
8121 args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
8122 if err != nil {
8123 ec.Error(ctx, err)
8124 return graphql.Null
8125 }
8126 fc.Args = args
8127 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8128 ctx = rctx // use context from middleware stack in children
8129 return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
8130 })
8131 if err != nil {
8132 ec.Error(ctx, err)
8133 return graphql.Null
8134 }
8135 if resTmp == nil {
8136 if !graphql.HasFieldError(ctx, fc) {
8137 ec.Errorf(ctx, "must not be null")
8138 }
8139 return graphql.Null
8140 }
8141 res := resTmp.(*models.BugConnection)
8142 fc.Result = res
8143 return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
8144}
8145
8146func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8147 defer func() {
8148 if r := recover(); r != nil {
8149 ec.Error(ctx, ec.Recover(ctx, r))
8150 ret = graphql.Null
8151 }
8152 }()
8153 fc := &graphql.FieldContext{
8154 Object: "Repository",
8155 Field: field,
8156 Args: nil,
8157 IsMethod: true,
8158 }
8159
8160 ctx = graphql.WithFieldContext(ctx, fc)
8161 rawArgs := field.ArgumentMap(ec.Variables)
8162 args, err := ec.field_Repository_bug_args(ctx, rawArgs)
8163 if err != nil {
8164 ec.Error(ctx, err)
8165 return graphql.Null
8166 }
8167 fc.Args = args
8168 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8169 ctx = rctx // use context from middleware stack in children
8170 return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
8171 })
8172 if err != nil {
8173 ec.Error(ctx, err)
8174 return graphql.Null
8175 }
8176 if resTmp == nil {
8177 return graphql.Null
8178 }
8179 res := resTmp.(models.BugWrapper)
8180 fc.Result = res
8181 return ec.marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
8182}
8183
8184func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8185 defer func() {
8186 if r := recover(); r != nil {
8187 ec.Error(ctx, ec.Recover(ctx, r))
8188 ret = graphql.Null
8189 }
8190 }()
8191 fc := &graphql.FieldContext{
8192 Object: "Repository",
8193 Field: field,
8194 Args: nil,
8195 IsMethod: true,
8196 }
8197
8198 ctx = graphql.WithFieldContext(ctx, fc)
8199 rawArgs := field.ArgumentMap(ec.Variables)
8200 args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
8201 if err != nil {
8202 ec.Error(ctx, err)
8203 return graphql.Null
8204 }
8205 fc.Args = args
8206 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8207 ctx = rctx // use context from middleware stack in children
8208 return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8209 })
8210 if err != nil {
8211 ec.Error(ctx, err)
8212 return graphql.Null
8213 }
8214 if resTmp == nil {
8215 if !graphql.HasFieldError(ctx, fc) {
8216 ec.Errorf(ctx, "must not be null")
8217 }
8218 return graphql.Null
8219 }
8220 res := resTmp.(*models.IdentityConnection)
8221 fc.Result = res
8222 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
8223}
8224
8225func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8226 defer func() {
8227 if r := recover(); r != nil {
8228 ec.Error(ctx, ec.Recover(ctx, r))
8229 ret = graphql.Null
8230 }
8231 }()
8232 fc := &graphql.FieldContext{
8233 Object: "Repository",
8234 Field: field,
8235 Args: nil,
8236 IsMethod: true,
8237 }
8238
8239 ctx = graphql.WithFieldContext(ctx, fc)
8240 rawArgs := field.ArgumentMap(ec.Variables)
8241 args, err := ec.field_Repository_identity_args(ctx, rawArgs)
8242 if err != nil {
8243 ec.Error(ctx, err)
8244 return graphql.Null
8245 }
8246 fc.Args = args
8247 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8248 ctx = rctx // use context from middleware stack in children
8249 return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
8250 })
8251 if err != nil {
8252 ec.Error(ctx, err)
8253 return graphql.Null
8254 }
8255 if resTmp == nil {
8256 return graphql.Null
8257 }
8258 res := resTmp.(models.IdentityWrapper)
8259 fc.Result = res
8260 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8261}
8262
8263func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8264 defer func() {
8265 if r := recover(); r != nil {
8266 ec.Error(ctx, ec.Recover(ctx, r))
8267 ret = graphql.Null
8268 }
8269 }()
8270 fc := &graphql.FieldContext{
8271 Object: "Repository",
8272 Field: field,
8273 Args: nil,
8274 IsMethod: true,
8275 }
8276
8277 ctx = graphql.WithFieldContext(ctx, fc)
8278 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8279 ctx = rctx // use context from middleware stack in children
8280 return ec.resolvers.Repository().UserIdentity(rctx, obj)
8281 })
8282 if err != nil {
8283 ec.Error(ctx, err)
8284 return graphql.Null
8285 }
8286 if resTmp == nil {
8287 return graphql.Null
8288 }
8289 res := resTmp.(models.IdentityWrapper)
8290 fc.Result = res
8291 return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8292}
8293
8294func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
8295 defer func() {
8296 if r := recover(); r != nil {
8297 ec.Error(ctx, ec.Recover(ctx, r))
8298 ret = graphql.Null
8299 }
8300 }()
8301 fc := &graphql.FieldContext{
8302 Object: "Repository",
8303 Field: field,
8304 Args: nil,
8305 IsMethod: true,
8306 }
8307
8308 ctx = graphql.WithFieldContext(ctx, fc)
8309 rawArgs := field.ArgumentMap(ec.Variables)
8310 args, err := ec.field_Repository_validLabels_args(ctx, rawArgs)
8311 if err != nil {
8312 ec.Error(ctx, err)
8313 return graphql.Null
8314 }
8315 fc.Args = args
8316 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8317 ctx = rctx // use context from middleware stack in children
8318 return ec.resolvers.Repository().ValidLabels(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
8319 })
8320 if err != nil {
8321 ec.Error(ctx, err)
8322 return graphql.Null
8323 }
8324 if resTmp == nil {
8325 if !graphql.HasFieldError(ctx, fc) {
8326 ec.Errorf(ctx, "must not be null")
8327 }
8328 return graphql.Null
8329 }
8330 res := resTmp.(*models.LabelConnection)
8331 fc.Result = res
8332 return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
8333}
8334
8335func (ec *executionContext) _RollbackPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.RollbackPayload) (ret graphql.Marshaler) {
8336 defer func() {
8337 if r := recover(); r != nil {
8338 ec.Error(ctx, ec.Recover(ctx, r))
8339 ret = graphql.Null
8340 }
8341 }()
8342 fc := &graphql.FieldContext{
8343 Object: "RollbackPayload",
8344 Field: field,
8345 Args: nil,
8346 IsMethod: false,
8347 }
8348
8349 ctx = graphql.WithFieldContext(ctx, fc)
8350 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8351 ctx = rctx // use context from middleware stack in children
8352 return obj.ClientMutationID, nil
8353 })
8354 if err != nil {
8355 ec.Error(ctx, err)
8356 return graphql.Null
8357 }
8358 if resTmp == nil {
8359 return graphql.Null
8360 }
8361 res := resTmp.(*string)
8362 fc.Result = res
8363 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
8364}
8365
8366func (ec *executionContext) _RollbackPayload_id(ctx context.Context, field graphql.CollectedField, obj *models.RollbackPayload) (ret graphql.Marshaler) {
8367 defer func() {
8368 if r := recover(); r != nil {
8369 ec.Error(ctx, ec.Recover(ctx, r))
8370 ret = graphql.Null
8371 }
8372 }()
8373 fc := &graphql.FieldContext{
8374 Object: "RollbackPayload",
8375 Field: field,
8376 Args: nil,
8377 IsMethod: false,
8378 }
8379
8380 ctx = graphql.WithFieldContext(ctx, fc)
8381 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8382 ctx = rctx // use context from middleware stack in children
8383 return obj.ID, nil
8384 })
8385 if err != nil {
8386 ec.Error(ctx, err)
8387 return graphql.Null
8388 }
8389 if resTmp == nil {
8390 if !graphql.HasFieldError(ctx, fc) {
8391 ec.Errorf(ctx, "must not be null")
8392 }
8393 return graphql.Null
8394 }
8395 res := resTmp.(string)
8396 fc.Result = res
8397 return ec.marshalNTxId2string(ctx, field.Selections, res)
8398}
8399
8400func (ec *executionContext) _RollbackPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.RollbackPayload) (ret graphql.Marshaler) {
8401 defer func() {
8402 if r := recover(); r != nil {
8403 ec.Error(ctx, ec.Recover(ctx, r))
8404 ret = graphql.Null
8405 }
8406 }()
8407 fc := &graphql.FieldContext{
8408 Object: "RollbackPayload",
8409 Field: field,
8410 Args: nil,
8411 IsMethod: false,
8412 }
8413
8414 ctx = graphql.WithFieldContext(ctx, fc)
8415 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8416 ctx = rctx // use context from middleware stack in children
8417 return obj.Bug, nil
8418 })
8419 if err != nil {
8420 ec.Error(ctx, err)
8421 return graphql.Null
8422 }
8423 if resTmp == nil {
8424 if !graphql.HasFieldError(ctx, fc) {
8425 ec.Errorf(ctx, "must not be null")
8426 }
8427 return graphql.Null
8428 }
8429 res := resTmp.(models.BugWrapper)
8430 fc.Result = res
8431 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
8432}
8433
8434func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8435 defer func() {
8436 if r := recover(); r != nil {
8437 ec.Error(ctx, ec.Recover(ctx, r))
8438 ret = graphql.Null
8439 }
8440 }()
8441 fc := &graphql.FieldContext{
8442 Object: "SetStatusOperation",
8443 Field: field,
8444 Args: nil,
8445 IsMethod: true,
8446 }
8447
8448 ctx = graphql.WithFieldContext(ctx, fc)
8449 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8450 ctx = rctx // use context from middleware stack in children
8451 return ec.resolvers.SetStatusOperation().ID(rctx, obj)
8452 })
8453 if err != nil {
8454 ec.Error(ctx, err)
8455 return graphql.Null
8456 }
8457 if resTmp == nil {
8458 if !graphql.HasFieldError(ctx, fc) {
8459 ec.Errorf(ctx, "must not be null")
8460 }
8461 return graphql.Null
8462 }
8463 res := resTmp.(string)
8464 fc.Result = res
8465 return ec.marshalNString2string(ctx, field.Selections, res)
8466}
8467
8468func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8469 defer func() {
8470 if r := recover(); r != nil {
8471 ec.Error(ctx, ec.Recover(ctx, r))
8472 ret = graphql.Null
8473 }
8474 }()
8475 fc := &graphql.FieldContext{
8476 Object: "SetStatusOperation",
8477 Field: field,
8478 Args: nil,
8479 IsMethod: true,
8480 }
8481
8482 ctx = graphql.WithFieldContext(ctx, fc)
8483 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8484 ctx = rctx // use context from middleware stack in children
8485 return ec.resolvers.SetStatusOperation().Author(rctx, obj)
8486 })
8487 if err != nil {
8488 ec.Error(ctx, err)
8489 return graphql.Null
8490 }
8491 if resTmp == nil {
8492 if !graphql.HasFieldError(ctx, fc) {
8493 ec.Errorf(ctx, "must not be null")
8494 }
8495 return graphql.Null
8496 }
8497 res := resTmp.(models.IdentityWrapper)
8498 fc.Result = res
8499 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8500}
8501
8502func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8503 defer func() {
8504 if r := recover(); r != nil {
8505 ec.Error(ctx, ec.Recover(ctx, r))
8506 ret = graphql.Null
8507 }
8508 }()
8509 fc := &graphql.FieldContext{
8510 Object: "SetStatusOperation",
8511 Field: field,
8512 Args: nil,
8513 IsMethod: true,
8514 }
8515
8516 ctx = graphql.WithFieldContext(ctx, fc)
8517 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8518 ctx = rctx // use context from middleware stack in children
8519 return ec.resolvers.SetStatusOperation().Date(rctx, obj)
8520 })
8521 if err != nil {
8522 ec.Error(ctx, err)
8523 return graphql.Null
8524 }
8525 if resTmp == nil {
8526 if !graphql.HasFieldError(ctx, fc) {
8527 ec.Errorf(ctx, "must not be null")
8528 }
8529 return graphql.Null
8530 }
8531 res := resTmp.(*time.Time)
8532 fc.Result = res
8533 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8534}
8535
8536func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
8537 defer func() {
8538 if r := recover(); r != nil {
8539 ec.Error(ctx, ec.Recover(ctx, r))
8540 ret = graphql.Null
8541 }
8542 }()
8543 fc := &graphql.FieldContext{
8544 Object: "SetStatusOperation",
8545 Field: field,
8546 Args: nil,
8547 IsMethod: true,
8548 }
8549
8550 ctx = graphql.WithFieldContext(ctx, fc)
8551 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8552 ctx = rctx // use context from middleware stack in children
8553 return ec.resolvers.SetStatusOperation().Status(rctx, obj)
8554 })
8555 if err != nil {
8556 ec.Error(ctx, err)
8557 return graphql.Null
8558 }
8559 if resTmp == nil {
8560 if !graphql.HasFieldError(ctx, fc) {
8561 ec.Errorf(ctx, "must not be null")
8562 }
8563 return graphql.Null
8564 }
8565 res := resTmp.(models.Status)
8566 fc.Result = res
8567 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8568}
8569
8570func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8571 defer func() {
8572 if r := recover(); r != nil {
8573 ec.Error(ctx, ec.Recover(ctx, r))
8574 ret = graphql.Null
8575 }
8576 }()
8577 fc := &graphql.FieldContext{
8578 Object: "SetStatusTimelineItem",
8579 Field: field,
8580 Args: nil,
8581 IsMethod: true,
8582 }
8583
8584 ctx = graphql.WithFieldContext(ctx, fc)
8585 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8586 ctx = rctx // use context from middleware stack in children
8587 return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
8588 })
8589 if err != nil {
8590 ec.Error(ctx, err)
8591 return graphql.Null
8592 }
8593 if resTmp == nil {
8594 if !graphql.HasFieldError(ctx, fc) {
8595 ec.Errorf(ctx, "must not be null")
8596 }
8597 return graphql.Null
8598 }
8599 res := resTmp.(string)
8600 fc.Result = res
8601 return ec.marshalNString2string(ctx, field.Selections, res)
8602}
8603
8604func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
8605 defer func() {
8606 if r := recover(); r != nil {
8607 ec.Error(ctx, ec.Recover(ctx, r))
8608 ret = graphql.Null
8609 }
8610 }()
8611 fc := &graphql.FieldContext{
8612 Object: "SetStatusTimelineItem",
8613 Field: field,
8614 Args: nil,
8615 IsMethod: true,
8616 }
8617
8618 ctx = graphql.WithFieldContext(ctx, fc)
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.SetStatusTimelineItem().Author(rctx, obj)
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.IdentityWrapper)
8634 fc.Result = res
8635 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8636}
8637
8638func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (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: "SetStatusTimelineItem",
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.SetStatusTimelineItem().Date(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.(*time.Time)
8668 fc.Result = res
8669 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8670}
8671
8672func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (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: "SetStatusTimelineItem",
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.SetStatusTimelineItem().Status(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.Status)
8702 fc.Result = res
8703 return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
8704}
8705
8706func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (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: "SetTitleOperation",
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.SetTitleOperation().ID(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.(string)
8736 fc.Result = res
8737 return ec.marshalNString2string(ctx, field.Selections, res)
8738}
8739
8740func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (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: "SetTitleOperation",
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.SetTitleOperation().Author(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.IdentityWrapper)
8770 fc.Result = res
8771 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
8772}
8773
8774func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (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: "SetTitleOperation",
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.SetTitleOperation().Date(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.(*time.Time)
8804 fc.Result = res
8805 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
8806}
8807
8808func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (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: "SetTitleOperation",
8817 Field: field,
8818 Args: nil,
8819 IsMethod: false,
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 obj.Title, nil
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.(string)
8838 fc.Result = res
8839 return ec.marshalNString2string(ctx, field.Selections, res)
8840}
8841
8842func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (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: "SetTitleOperation",
8851 Field: field,
8852 Args: nil,
8853 IsMethod: false,
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 obj.Was, nil
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.(string)
8872 fc.Result = res
8873 return ec.marshalNString2string(ctx, field.Selections, res)
8874}
8875
8876func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (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: "SetTitlePayload",
8885 Field: field,
8886 Args: nil,
8887 IsMethod: false,
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 obj.ClientMutationID, nil
8894 })
8895 if err != nil {
8896 ec.Error(ctx, err)
8897 return graphql.Null
8898 }
8899 if resTmp == nil {
8900 return graphql.Null
8901 }
8902 res := resTmp.(*string)
8903 fc.Result = res
8904 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
8905}
8906
8907func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8908 defer func() {
8909 if r := recover(); r != nil {
8910 ec.Error(ctx, ec.Recover(ctx, r))
8911 ret = graphql.Null
8912 }
8913 }()
8914 fc := &graphql.FieldContext{
8915 Object: "SetTitlePayload",
8916 Field: field,
8917 Args: nil,
8918 IsMethod: false,
8919 }
8920
8921 ctx = graphql.WithFieldContext(ctx, fc)
8922 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8923 ctx = rctx // use context from middleware stack in children
8924 return obj.Bug, nil
8925 })
8926 if err != nil {
8927 ec.Error(ctx, err)
8928 return graphql.Null
8929 }
8930 if resTmp == nil {
8931 if !graphql.HasFieldError(ctx, fc) {
8932 ec.Errorf(ctx, "must not be null")
8933 }
8934 return graphql.Null
8935 }
8936 res := resTmp.(models.BugWrapper)
8937 fc.Result = res
8938 return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
8939}
8940
8941func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
8942 defer func() {
8943 if r := recover(); r != nil {
8944 ec.Error(ctx, ec.Recover(ctx, r))
8945 ret = graphql.Null
8946 }
8947 }()
8948 fc := &graphql.FieldContext{
8949 Object: "SetTitlePayload",
8950 Field: field,
8951 Args: nil,
8952 IsMethod: false,
8953 }
8954
8955 ctx = graphql.WithFieldContext(ctx, fc)
8956 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8957 ctx = rctx // use context from middleware stack in children
8958 return obj.Operation, nil
8959 })
8960 if err != nil {
8961 ec.Error(ctx, err)
8962 return graphql.Null
8963 }
8964 if resTmp == nil {
8965 if !graphql.HasFieldError(ctx, fc) {
8966 ec.Errorf(ctx, "must not be null")
8967 }
8968 return graphql.Null
8969 }
8970 res := resTmp.(*bug.SetTitleOperation)
8971 fc.Result = res
8972 return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
8973}
8974
8975func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
8976 defer func() {
8977 if r := recover(); r != nil {
8978 ec.Error(ctx, ec.Recover(ctx, r))
8979 ret = graphql.Null
8980 }
8981 }()
8982 fc := &graphql.FieldContext{
8983 Object: "SetTitleTimelineItem",
8984 Field: field,
8985 Args: nil,
8986 IsMethod: true,
8987 }
8988
8989 ctx = graphql.WithFieldContext(ctx, fc)
8990 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
8991 ctx = rctx // use context from middleware stack in children
8992 return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
8993 })
8994 if err != nil {
8995 ec.Error(ctx, err)
8996 return graphql.Null
8997 }
8998 if resTmp == nil {
8999 if !graphql.HasFieldError(ctx, fc) {
9000 ec.Errorf(ctx, "must not be null")
9001 }
9002 return graphql.Null
9003 }
9004 res := resTmp.(string)
9005 fc.Result = res
9006 return ec.marshalNString2string(ctx, field.Selections, res)
9007}
9008
9009func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9010 defer func() {
9011 if r := recover(); r != nil {
9012 ec.Error(ctx, ec.Recover(ctx, r))
9013 ret = graphql.Null
9014 }
9015 }()
9016 fc := &graphql.FieldContext{
9017 Object: "SetTitleTimelineItem",
9018 Field: field,
9019 Args: nil,
9020 IsMethod: true,
9021 }
9022
9023 ctx = graphql.WithFieldContext(ctx, fc)
9024 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9025 ctx = rctx // use context from middleware stack in children
9026 return ec.resolvers.SetTitleTimelineItem().Author(rctx, obj)
9027 })
9028 if err != nil {
9029 ec.Error(ctx, err)
9030 return graphql.Null
9031 }
9032 if resTmp == nil {
9033 if !graphql.HasFieldError(ctx, fc) {
9034 ec.Errorf(ctx, "must not be null")
9035 }
9036 return graphql.Null
9037 }
9038 res := resTmp.(models.IdentityWrapper)
9039 fc.Result = res
9040 return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
9041}
9042
9043func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9044 defer func() {
9045 if r := recover(); r != nil {
9046 ec.Error(ctx, ec.Recover(ctx, r))
9047 ret = graphql.Null
9048 }
9049 }()
9050 fc := &graphql.FieldContext{
9051 Object: "SetTitleTimelineItem",
9052 Field: field,
9053 Args: nil,
9054 IsMethod: true,
9055 }
9056
9057 ctx = graphql.WithFieldContext(ctx, fc)
9058 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9059 ctx = rctx // use context from middleware stack in children
9060 return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
9061 })
9062 if err != nil {
9063 ec.Error(ctx, err)
9064 return graphql.Null
9065 }
9066 if resTmp == nil {
9067 if !graphql.HasFieldError(ctx, fc) {
9068 ec.Errorf(ctx, "must not be null")
9069 }
9070 return graphql.Null
9071 }
9072 res := resTmp.(*time.Time)
9073 fc.Result = res
9074 return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
9075}
9076
9077func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
9078 defer func() {
9079 if r := recover(); r != nil {
9080 ec.Error(ctx, ec.Recover(ctx, r))
9081 ret = graphql.Null
9082 }
9083 }()
9084 fc := &graphql.FieldContext{
9085 Object: "SetTitleTimelineItem",
9086 Field: field,
9087 Args: nil,
9088 IsMethod: false,
9089 }
9090
9091 ctx = graphql.WithFieldContext(ctx, fc)
9092 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9093 ctx = rctx // use context from middleware stack in children
9094 return obj.Title, nil
9095 })
9096 if err != nil {
9097 ec.Error(ctx, err)
9098 return graphql.Null
9099 }
9100 if resTmp == nil {
9101 if !graphql.HasFieldError(ctx, fc) {
9102 ec.Errorf(ctx, "must not be null")
9103 }
9104 return graphql.Null
9105 }
9106 res := resTmp.(string)
9107 fc.Result = res
9108 return ec.marshalNString2string(ctx, field.Selections, res)
9109}
9110
9111func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (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: "SetTitleTimelineItem",
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.Was, 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.(string)
9141 fc.Result = res
9142 return ec.marshalNString2string(ctx, field.Selections, res)
9143}
9144
9145func (ec *executionContext) _StartTransactionPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.StartTransactionPayload) (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: "StartTransactionPayload",
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.ClientMutationID, nil
9163 })
9164 if err != nil {
9165 ec.Error(ctx, err)
9166 return graphql.Null
9167 }
9168 if resTmp == nil {
9169 return graphql.Null
9170 }
9171 res := resTmp.(*string)
9172 fc.Result = res
9173 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9174}
9175
9176func (ec *executionContext) _StartTransactionPayload_id(ctx context.Context, field graphql.CollectedField, obj *models.StartTransactionPayload) (ret graphql.Marshaler) {
9177 defer func() {
9178 if r := recover(); r != nil {
9179 ec.Error(ctx, ec.Recover(ctx, r))
9180 ret = graphql.Null
9181 }
9182 }()
9183 fc := &graphql.FieldContext{
9184 Object: "StartTransactionPayload",
9185 Field: field,
9186 Args: nil,
9187 IsMethod: false,
9188 }
9189
9190 ctx = graphql.WithFieldContext(ctx, fc)
9191 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9192 ctx = rctx // use context from middleware stack in children
9193 return obj.ID, nil
9194 })
9195 if err != nil {
9196 ec.Error(ctx, err)
9197 return graphql.Null
9198 }
9199 if resTmp == nil {
9200 if !graphql.HasFieldError(ctx, fc) {
9201 ec.Errorf(ctx, "must not be null")
9202 }
9203 return graphql.Null
9204 }
9205 res := resTmp.(string)
9206 fc.Result = res
9207 return ec.marshalNTxId2string(ctx, field.Selections, res)
9208}
9209
9210func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9211 defer func() {
9212 if r := recover(); r != nil {
9213 ec.Error(ctx, ec.Recover(ctx, r))
9214 ret = graphql.Null
9215 }
9216 }()
9217 fc := &graphql.FieldContext{
9218 Object: "TimelineItemConnection",
9219 Field: field,
9220 Args: nil,
9221 IsMethod: false,
9222 }
9223
9224 ctx = graphql.WithFieldContext(ctx, fc)
9225 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9226 ctx = rctx // use context from middleware stack in children
9227 return obj.Edges, nil
9228 })
9229 if err != nil {
9230 ec.Error(ctx, err)
9231 return graphql.Null
9232 }
9233 if resTmp == nil {
9234 if !graphql.HasFieldError(ctx, fc) {
9235 ec.Errorf(ctx, "must not be null")
9236 }
9237 return graphql.Null
9238 }
9239 res := resTmp.([]*models.TimelineItemEdge)
9240 fc.Result = res
9241 return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx, field.Selections, res)
9242}
9243
9244func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9245 defer func() {
9246 if r := recover(); r != nil {
9247 ec.Error(ctx, ec.Recover(ctx, r))
9248 ret = graphql.Null
9249 }
9250 }()
9251 fc := &graphql.FieldContext{
9252 Object: "TimelineItemConnection",
9253 Field: field,
9254 Args: nil,
9255 IsMethod: false,
9256 }
9257
9258 ctx = graphql.WithFieldContext(ctx, fc)
9259 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9260 ctx = rctx // use context from middleware stack in children
9261 return obj.Nodes, nil
9262 })
9263 if err != nil {
9264 ec.Error(ctx, err)
9265 return graphql.Null
9266 }
9267 if resTmp == nil {
9268 if !graphql.HasFieldError(ctx, fc) {
9269 ec.Errorf(ctx, "must not be null")
9270 }
9271 return graphql.Null
9272 }
9273 res := resTmp.([]bug.TimelineItem)
9274 fc.Result = res
9275 return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx, field.Selections, res)
9276}
9277
9278func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9279 defer func() {
9280 if r := recover(); r != nil {
9281 ec.Error(ctx, ec.Recover(ctx, r))
9282 ret = graphql.Null
9283 }
9284 }()
9285 fc := &graphql.FieldContext{
9286 Object: "TimelineItemConnection",
9287 Field: field,
9288 Args: nil,
9289 IsMethod: false,
9290 }
9291
9292 ctx = graphql.WithFieldContext(ctx, fc)
9293 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9294 ctx = rctx // use context from middleware stack in children
9295 return obj.PageInfo, nil
9296 })
9297 if err != nil {
9298 ec.Error(ctx, err)
9299 return graphql.Null
9300 }
9301 if resTmp == nil {
9302 if !graphql.HasFieldError(ctx, fc) {
9303 ec.Errorf(ctx, "must not be null")
9304 }
9305 return graphql.Null
9306 }
9307 res := resTmp.(*models.PageInfo)
9308 fc.Result = res
9309 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
9310}
9311
9312func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
9313 defer func() {
9314 if r := recover(); r != nil {
9315 ec.Error(ctx, ec.Recover(ctx, r))
9316 ret = graphql.Null
9317 }
9318 }()
9319 fc := &graphql.FieldContext{
9320 Object: "TimelineItemConnection",
9321 Field: field,
9322 Args: nil,
9323 IsMethod: false,
9324 }
9325
9326 ctx = graphql.WithFieldContext(ctx, fc)
9327 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9328 ctx = rctx // use context from middleware stack in children
9329 return obj.TotalCount, nil
9330 })
9331 if err != nil {
9332 ec.Error(ctx, err)
9333 return graphql.Null
9334 }
9335 if resTmp == nil {
9336 if !graphql.HasFieldError(ctx, fc) {
9337 ec.Errorf(ctx, "must not be null")
9338 }
9339 return graphql.Null
9340 }
9341 res := resTmp.(int)
9342 fc.Result = res
9343 return ec.marshalNInt2int(ctx, field.Selections, res)
9344}
9345
9346func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9347 defer func() {
9348 if r := recover(); r != nil {
9349 ec.Error(ctx, ec.Recover(ctx, r))
9350 ret = graphql.Null
9351 }
9352 }()
9353 fc := &graphql.FieldContext{
9354 Object: "TimelineItemEdge",
9355 Field: field,
9356 Args: nil,
9357 IsMethod: false,
9358 }
9359
9360 ctx = graphql.WithFieldContext(ctx, fc)
9361 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9362 ctx = rctx // use context from middleware stack in children
9363 return obj.Cursor, nil
9364 })
9365 if err != nil {
9366 ec.Error(ctx, err)
9367 return graphql.Null
9368 }
9369 if resTmp == nil {
9370 if !graphql.HasFieldError(ctx, fc) {
9371 ec.Errorf(ctx, "must not be null")
9372 }
9373 return graphql.Null
9374 }
9375 res := resTmp.(string)
9376 fc.Result = res
9377 return ec.marshalNString2string(ctx, field.Selections, res)
9378}
9379
9380func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
9381 defer func() {
9382 if r := recover(); r != nil {
9383 ec.Error(ctx, ec.Recover(ctx, r))
9384 ret = graphql.Null
9385 }
9386 }()
9387 fc := &graphql.FieldContext{
9388 Object: "TimelineItemEdge",
9389 Field: field,
9390 Args: nil,
9391 IsMethod: false,
9392 }
9393
9394 ctx = graphql.WithFieldContext(ctx, fc)
9395 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9396 ctx = rctx // use context from middleware stack in children
9397 return obj.Node, nil
9398 })
9399 if err != nil {
9400 ec.Error(ctx, err)
9401 return graphql.Null
9402 }
9403 if resTmp == nil {
9404 if !graphql.HasFieldError(ctx, fc) {
9405 ec.Errorf(ctx, "must not be null")
9406 }
9407 return graphql.Null
9408 }
9409 res := resTmp.(bug.TimelineItem)
9410 fc.Result = res
9411 return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
9412}
9413
9414func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9415 defer func() {
9416 if r := recover(); r != nil {
9417 ec.Error(ctx, ec.Recover(ctx, r))
9418 ret = graphql.Null
9419 }
9420 }()
9421 fc := &graphql.FieldContext{
9422 Object: "__Directive",
9423 Field: field,
9424 Args: nil,
9425 IsMethod: false,
9426 }
9427
9428 ctx = graphql.WithFieldContext(ctx, fc)
9429 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9430 ctx = rctx // use context from middleware stack in children
9431 return obj.Name, nil
9432 })
9433 if err != nil {
9434 ec.Error(ctx, err)
9435 return graphql.Null
9436 }
9437 if resTmp == nil {
9438 if !graphql.HasFieldError(ctx, fc) {
9439 ec.Errorf(ctx, "must not be null")
9440 }
9441 return graphql.Null
9442 }
9443 res := resTmp.(string)
9444 fc.Result = res
9445 return ec.marshalNString2string(ctx, field.Selections, res)
9446}
9447
9448func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9449 defer func() {
9450 if r := recover(); r != nil {
9451 ec.Error(ctx, ec.Recover(ctx, r))
9452 ret = graphql.Null
9453 }
9454 }()
9455 fc := &graphql.FieldContext{
9456 Object: "__Directive",
9457 Field: field,
9458 Args: nil,
9459 IsMethod: false,
9460 }
9461
9462 ctx = graphql.WithFieldContext(ctx, fc)
9463 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9464 ctx = rctx // use context from middleware stack in children
9465 return obj.Description, nil
9466 })
9467 if err != nil {
9468 ec.Error(ctx, err)
9469 return graphql.Null
9470 }
9471 if resTmp == nil {
9472 return graphql.Null
9473 }
9474 res := resTmp.(string)
9475 fc.Result = res
9476 return ec.marshalOString2string(ctx, field.Selections, res)
9477}
9478
9479func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9480 defer func() {
9481 if r := recover(); r != nil {
9482 ec.Error(ctx, ec.Recover(ctx, r))
9483 ret = graphql.Null
9484 }
9485 }()
9486 fc := &graphql.FieldContext{
9487 Object: "__Directive",
9488 Field: field,
9489 Args: nil,
9490 IsMethod: false,
9491 }
9492
9493 ctx = graphql.WithFieldContext(ctx, fc)
9494 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9495 ctx = rctx // use context from middleware stack in children
9496 return obj.Locations, nil
9497 })
9498 if err != nil {
9499 ec.Error(ctx, err)
9500 return graphql.Null
9501 }
9502 if resTmp == nil {
9503 if !graphql.HasFieldError(ctx, fc) {
9504 ec.Errorf(ctx, "must not be null")
9505 }
9506 return graphql.Null
9507 }
9508 res := resTmp.([]string)
9509 fc.Result = res
9510 return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
9511}
9512
9513func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
9514 defer func() {
9515 if r := recover(); r != nil {
9516 ec.Error(ctx, ec.Recover(ctx, r))
9517 ret = graphql.Null
9518 }
9519 }()
9520 fc := &graphql.FieldContext{
9521 Object: "__Directive",
9522 Field: field,
9523 Args: nil,
9524 IsMethod: false,
9525 }
9526
9527 ctx = graphql.WithFieldContext(ctx, fc)
9528 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9529 ctx = rctx // use context from middleware stack in children
9530 return obj.Args, nil
9531 })
9532 if err != nil {
9533 ec.Error(ctx, err)
9534 return graphql.Null
9535 }
9536 if resTmp == nil {
9537 if !graphql.HasFieldError(ctx, fc) {
9538 ec.Errorf(ctx, "must not be null")
9539 }
9540 return graphql.Null
9541 }
9542 res := resTmp.([]introspection.InputValue)
9543 fc.Result = res
9544 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
9545}
9546
9547func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9548 defer func() {
9549 if r := recover(); r != nil {
9550 ec.Error(ctx, ec.Recover(ctx, r))
9551 ret = graphql.Null
9552 }
9553 }()
9554 fc := &graphql.FieldContext{
9555 Object: "__EnumValue",
9556 Field: field,
9557 Args: nil,
9558 IsMethod: false,
9559 }
9560
9561 ctx = graphql.WithFieldContext(ctx, fc)
9562 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9563 ctx = rctx // use context from middleware stack in children
9564 return obj.Name, nil
9565 })
9566 if err != nil {
9567 ec.Error(ctx, err)
9568 return graphql.Null
9569 }
9570 if resTmp == nil {
9571 if !graphql.HasFieldError(ctx, fc) {
9572 ec.Errorf(ctx, "must not be null")
9573 }
9574 return graphql.Null
9575 }
9576 res := resTmp.(string)
9577 fc.Result = res
9578 return ec.marshalNString2string(ctx, field.Selections, res)
9579}
9580
9581func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9582 defer func() {
9583 if r := recover(); r != nil {
9584 ec.Error(ctx, ec.Recover(ctx, r))
9585 ret = graphql.Null
9586 }
9587 }()
9588 fc := &graphql.FieldContext{
9589 Object: "__EnumValue",
9590 Field: field,
9591 Args: nil,
9592 IsMethod: false,
9593 }
9594
9595 ctx = graphql.WithFieldContext(ctx, fc)
9596 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9597 ctx = rctx // use context from middleware stack in children
9598 return obj.Description, nil
9599 })
9600 if err != nil {
9601 ec.Error(ctx, err)
9602 return graphql.Null
9603 }
9604 if resTmp == nil {
9605 return graphql.Null
9606 }
9607 res := resTmp.(string)
9608 fc.Result = res
9609 return ec.marshalOString2string(ctx, field.Selections, res)
9610}
9611
9612func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9613 defer func() {
9614 if r := recover(); r != nil {
9615 ec.Error(ctx, ec.Recover(ctx, r))
9616 ret = graphql.Null
9617 }
9618 }()
9619 fc := &graphql.FieldContext{
9620 Object: "__EnumValue",
9621 Field: field,
9622 Args: nil,
9623 IsMethod: true,
9624 }
9625
9626 ctx = graphql.WithFieldContext(ctx, fc)
9627 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9628 ctx = rctx // use context from middleware stack in children
9629 return obj.IsDeprecated(), nil
9630 })
9631 if err != nil {
9632 ec.Error(ctx, err)
9633 return graphql.Null
9634 }
9635 if resTmp == nil {
9636 if !graphql.HasFieldError(ctx, fc) {
9637 ec.Errorf(ctx, "must not be null")
9638 }
9639 return graphql.Null
9640 }
9641 res := resTmp.(bool)
9642 fc.Result = res
9643 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9644}
9645
9646func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
9647 defer func() {
9648 if r := recover(); r != nil {
9649 ec.Error(ctx, ec.Recover(ctx, r))
9650 ret = graphql.Null
9651 }
9652 }()
9653 fc := &graphql.FieldContext{
9654 Object: "__EnumValue",
9655 Field: field,
9656 Args: nil,
9657 IsMethod: true,
9658 }
9659
9660 ctx = graphql.WithFieldContext(ctx, fc)
9661 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9662 ctx = rctx // use context from middleware stack in children
9663 return obj.DeprecationReason(), nil
9664 })
9665 if err != nil {
9666 ec.Error(ctx, err)
9667 return graphql.Null
9668 }
9669 if resTmp == nil {
9670 return graphql.Null
9671 }
9672 res := resTmp.(*string)
9673 fc.Result = res
9674 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9675}
9676
9677func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9678 defer func() {
9679 if r := recover(); r != nil {
9680 ec.Error(ctx, ec.Recover(ctx, r))
9681 ret = graphql.Null
9682 }
9683 }()
9684 fc := &graphql.FieldContext{
9685 Object: "__Field",
9686 Field: field,
9687 Args: nil,
9688 IsMethod: false,
9689 }
9690
9691 ctx = graphql.WithFieldContext(ctx, fc)
9692 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9693 ctx = rctx // use context from middleware stack in children
9694 return obj.Name, nil
9695 })
9696 if err != nil {
9697 ec.Error(ctx, err)
9698 return graphql.Null
9699 }
9700 if resTmp == nil {
9701 if !graphql.HasFieldError(ctx, fc) {
9702 ec.Errorf(ctx, "must not be null")
9703 }
9704 return graphql.Null
9705 }
9706 res := resTmp.(string)
9707 fc.Result = res
9708 return ec.marshalNString2string(ctx, field.Selections, res)
9709}
9710
9711func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9712 defer func() {
9713 if r := recover(); r != nil {
9714 ec.Error(ctx, ec.Recover(ctx, r))
9715 ret = graphql.Null
9716 }
9717 }()
9718 fc := &graphql.FieldContext{
9719 Object: "__Field",
9720 Field: field,
9721 Args: nil,
9722 IsMethod: false,
9723 }
9724
9725 ctx = graphql.WithFieldContext(ctx, fc)
9726 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9727 ctx = rctx // use context from middleware stack in children
9728 return obj.Description, nil
9729 })
9730 if err != nil {
9731 ec.Error(ctx, err)
9732 return graphql.Null
9733 }
9734 if resTmp == nil {
9735 return graphql.Null
9736 }
9737 res := resTmp.(string)
9738 fc.Result = res
9739 return ec.marshalOString2string(ctx, field.Selections, res)
9740}
9741
9742func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9743 defer func() {
9744 if r := recover(); r != nil {
9745 ec.Error(ctx, ec.Recover(ctx, r))
9746 ret = graphql.Null
9747 }
9748 }()
9749 fc := &graphql.FieldContext{
9750 Object: "__Field",
9751 Field: field,
9752 Args: nil,
9753 IsMethod: false,
9754 }
9755
9756 ctx = graphql.WithFieldContext(ctx, fc)
9757 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9758 ctx = rctx // use context from middleware stack in children
9759 return obj.Args, nil
9760 })
9761 if err != nil {
9762 ec.Error(ctx, err)
9763 return graphql.Null
9764 }
9765 if resTmp == nil {
9766 if !graphql.HasFieldError(ctx, fc) {
9767 ec.Errorf(ctx, "must not be null")
9768 }
9769 return graphql.Null
9770 }
9771 res := resTmp.([]introspection.InputValue)
9772 fc.Result = res
9773 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
9774}
9775
9776func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9777 defer func() {
9778 if r := recover(); r != nil {
9779 ec.Error(ctx, ec.Recover(ctx, r))
9780 ret = graphql.Null
9781 }
9782 }()
9783 fc := &graphql.FieldContext{
9784 Object: "__Field",
9785 Field: field,
9786 Args: nil,
9787 IsMethod: false,
9788 }
9789
9790 ctx = graphql.WithFieldContext(ctx, fc)
9791 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9792 ctx = rctx // use context from middleware stack in children
9793 return obj.Type, nil
9794 })
9795 if err != nil {
9796 ec.Error(ctx, err)
9797 return graphql.Null
9798 }
9799 if resTmp == nil {
9800 if !graphql.HasFieldError(ctx, fc) {
9801 ec.Errorf(ctx, "must not be null")
9802 }
9803 return graphql.Null
9804 }
9805 res := resTmp.(*introspection.Type)
9806 fc.Result = res
9807 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9808}
9809
9810func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9811 defer func() {
9812 if r := recover(); r != nil {
9813 ec.Error(ctx, ec.Recover(ctx, r))
9814 ret = graphql.Null
9815 }
9816 }()
9817 fc := &graphql.FieldContext{
9818 Object: "__Field",
9819 Field: field,
9820 Args: nil,
9821 IsMethod: true,
9822 }
9823
9824 ctx = graphql.WithFieldContext(ctx, fc)
9825 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9826 ctx = rctx // use context from middleware stack in children
9827 return obj.IsDeprecated(), nil
9828 })
9829 if err != nil {
9830 ec.Error(ctx, err)
9831 return graphql.Null
9832 }
9833 if resTmp == nil {
9834 if !graphql.HasFieldError(ctx, fc) {
9835 ec.Errorf(ctx, "must not be null")
9836 }
9837 return graphql.Null
9838 }
9839 res := resTmp.(bool)
9840 fc.Result = res
9841 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
9842}
9843
9844func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
9845 defer func() {
9846 if r := recover(); r != nil {
9847 ec.Error(ctx, ec.Recover(ctx, r))
9848 ret = graphql.Null
9849 }
9850 }()
9851 fc := &graphql.FieldContext{
9852 Object: "__Field",
9853 Field: field,
9854 Args: nil,
9855 IsMethod: true,
9856 }
9857
9858 ctx = graphql.WithFieldContext(ctx, fc)
9859 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9860 ctx = rctx // use context from middleware stack in children
9861 return obj.DeprecationReason(), nil
9862 })
9863 if err != nil {
9864 ec.Error(ctx, err)
9865 return graphql.Null
9866 }
9867 if resTmp == nil {
9868 return graphql.Null
9869 }
9870 res := resTmp.(*string)
9871 fc.Result = res
9872 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9873}
9874
9875func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9876 defer func() {
9877 if r := recover(); r != nil {
9878 ec.Error(ctx, ec.Recover(ctx, r))
9879 ret = graphql.Null
9880 }
9881 }()
9882 fc := &graphql.FieldContext{
9883 Object: "__InputValue",
9884 Field: field,
9885 Args: nil,
9886 IsMethod: false,
9887 }
9888
9889 ctx = graphql.WithFieldContext(ctx, fc)
9890 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9891 ctx = rctx // use context from middleware stack in children
9892 return obj.Name, nil
9893 })
9894 if err != nil {
9895 ec.Error(ctx, err)
9896 return graphql.Null
9897 }
9898 if resTmp == nil {
9899 if !graphql.HasFieldError(ctx, fc) {
9900 ec.Errorf(ctx, "must not be null")
9901 }
9902 return graphql.Null
9903 }
9904 res := resTmp.(string)
9905 fc.Result = res
9906 return ec.marshalNString2string(ctx, field.Selections, res)
9907}
9908
9909func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9910 defer func() {
9911 if r := recover(); r != nil {
9912 ec.Error(ctx, ec.Recover(ctx, r))
9913 ret = graphql.Null
9914 }
9915 }()
9916 fc := &graphql.FieldContext{
9917 Object: "__InputValue",
9918 Field: field,
9919 Args: nil,
9920 IsMethod: false,
9921 }
9922
9923 ctx = graphql.WithFieldContext(ctx, fc)
9924 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9925 ctx = rctx // use context from middleware stack in children
9926 return obj.Description, nil
9927 })
9928 if err != nil {
9929 ec.Error(ctx, err)
9930 return graphql.Null
9931 }
9932 if resTmp == nil {
9933 return graphql.Null
9934 }
9935 res := resTmp.(string)
9936 fc.Result = res
9937 return ec.marshalOString2string(ctx, field.Selections, res)
9938}
9939
9940func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9941 defer func() {
9942 if r := recover(); r != nil {
9943 ec.Error(ctx, ec.Recover(ctx, r))
9944 ret = graphql.Null
9945 }
9946 }()
9947 fc := &graphql.FieldContext{
9948 Object: "__InputValue",
9949 Field: field,
9950 Args: nil,
9951 IsMethod: false,
9952 }
9953
9954 ctx = graphql.WithFieldContext(ctx, fc)
9955 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9956 ctx = rctx // use context from middleware stack in children
9957 return obj.Type, nil
9958 })
9959 if err != nil {
9960 ec.Error(ctx, err)
9961 return graphql.Null
9962 }
9963 if resTmp == nil {
9964 if !graphql.HasFieldError(ctx, fc) {
9965 ec.Errorf(ctx, "must not be null")
9966 }
9967 return graphql.Null
9968 }
9969 res := resTmp.(*introspection.Type)
9970 fc.Result = res
9971 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
9972}
9973
9974func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
9975 defer func() {
9976 if r := recover(); r != nil {
9977 ec.Error(ctx, ec.Recover(ctx, r))
9978 ret = graphql.Null
9979 }
9980 }()
9981 fc := &graphql.FieldContext{
9982 Object: "__InputValue",
9983 Field: field,
9984 Args: nil,
9985 IsMethod: false,
9986 }
9987
9988 ctx = graphql.WithFieldContext(ctx, fc)
9989 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
9990 ctx = rctx // use context from middleware stack in children
9991 return obj.DefaultValue, nil
9992 })
9993 if err != nil {
9994 ec.Error(ctx, err)
9995 return graphql.Null
9996 }
9997 if resTmp == nil {
9998 return graphql.Null
9999 }
10000 res := resTmp.(*string)
10001 fc.Result = res
10002 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10003}
10004
10005func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10006 defer func() {
10007 if r := recover(); r != nil {
10008 ec.Error(ctx, ec.Recover(ctx, r))
10009 ret = graphql.Null
10010 }
10011 }()
10012 fc := &graphql.FieldContext{
10013 Object: "__Schema",
10014 Field: field,
10015 Args: nil,
10016 IsMethod: true,
10017 }
10018
10019 ctx = graphql.WithFieldContext(ctx, fc)
10020 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10021 ctx = rctx // use context from middleware stack in children
10022 return obj.Types(), nil
10023 })
10024 if err != nil {
10025 ec.Error(ctx, err)
10026 return graphql.Null
10027 }
10028 if resTmp == nil {
10029 if !graphql.HasFieldError(ctx, fc) {
10030 ec.Errorf(ctx, "must not be null")
10031 }
10032 return graphql.Null
10033 }
10034 res := resTmp.([]introspection.Type)
10035 fc.Result = res
10036 return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10037}
10038
10039func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10040 defer func() {
10041 if r := recover(); r != nil {
10042 ec.Error(ctx, ec.Recover(ctx, r))
10043 ret = graphql.Null
10044 }
10045 }()
10046 fc := &graphql.FieldContext{
10047 Object: "__Schema",
10048 Field: field,
10049 Args: nil,
10050 IsMethod: true,
10051 }
10052
10053 ctx = graphql.WithFieldContext(ctx, fc)
10054 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10055 ctx = rctx // use context from middleware stack in children
10056 return obj.QueryType(), nil
10057 })
10058 if err != nil {
10059 ec.Error(ctx, err)
10060 return graphql.Null
10061 }
10062 if resTmp == nil {
10063 if !graphql.HasFieldError(ctx, fc) {
10064 ec.Errorf(ctx, "must not be null")
10065 }
10066 return graphql.Null
10067 }
10068 res := resTmp.(*introspection.Type)
10069 fc.Result = res
10070 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10071}
10072
10073func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10074 defer func() {
10075 if r := recover(); r != nil {
10076 ec.Error(ctx, ec.Recover(ctx, r))
10077 ret = graphql.Null
10078 }
10079 }()
10080 fc := &graphql.FieldContext{
10081 Object: "__Schema",
10082 Field: field,
10083 Args: nil,
10084 IsMethod: true,
10085 }
10086
10087 ctx = graphql.WithFieldContext(ctx, fc)
10088 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10089 ctx = rctx // use context from middleware stack in children
10090 return obj.MutationType(), nil
10091 })
10092 if err != nil {
10093 ec.Error(ctx, err)
10094 return graphql.Null
10095 }
10096 if resTmp == nil {
10097 return graphql.Null
10098 }
10099 res := resTmp.(*introspection.Type)
10100 fc.Result = res
10101 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10102}
10103
10104func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10105 defer func() {
10106 if r := recover(); r != nil {
10107 ec.Error(ctx, ec.Recover(ctx, r))
10108 ret = graphql.Null
10109 }
10110 }()
10111 fc := &graphql.FieldContext{
10112 Object: "__Schema",
10113 Field: field,
10114 Args: nil,
10115 IsMethod: true,
10116 }
10117
10118 ctx = graphql.WithFieldContext(ctx, fc)
10119 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10120 ctx = rctx // use context from middleware stack in children
10121 return obj.SubscriptionType(), nil
10122 })
10123 if err != nil {
10124 ec.Error(ctx, err)
10125 return graphql.Null
10126 }
10127 if resTmp == nil {
10128 return graphql.Null
10129 }
10130 res := resTmp.(*introspection.Type)
10131 fc.Result = res
10132 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10133}
10134
10135func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10136 defer func() {
10137 if r := recover(); r != nil {
10138 ec.Error(ctx, ec.Recover(ctx, r))
10139 ret = graphql.Null
10140 }
10141 }()
10142 fc := &graphql.FieldContext{
10143 Object: "__Schema",
10144 Field: field,
10145 Args: nil,
10146 IsMethod: true,
10147 }
10148
10149 ctx = graphql.WithFieldContext(ctx, fc)
10150 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10151 ctx = rctx // use context from middleware stack in children
10152 return obj.Directives(), nil
10153 })
10154 if err != nil {
10155 ec.Error(ctx, err)
10156 return graphql.Null
10157 }
10158 if resTmp == nil {
10159 if !graphql.HasFieldError(ctx, fc) {
10160 ec.Errorf(ctx, "must not be null")
10161 }
10162 return graphql.Null
10163 }
10164 res := resTmp.([]introspection.Directive)
10165 fc.Result = res
10166 return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
10167}
10168
10169func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10170 defer func() {
10171 if r := recover(); r != nil {
10172 ec.Error(ctx, ec.Recover(ctx, r))
10173 ret = graphql.Null
10174 }
10175 }()
10176 fc := &graphql.FieldContext{
10177 Object: "__Type",
10178 Field: field,
10179 Args: nil,
10180 IsMethod: true,
10181 }
10182
10183 ctx = graphql.WithFieldContext(ctx, fc)
10184 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10185 ctx = rctx // use context from middleware stack in children
10186 return obj.Kind(), nil
10187 })
10188 if err != nil {
10189 ec.Error(ctx, err)
10190 return graphql.Null
10191 }
10192 if resTmp == nil {
10193 if !graphql.HasFieldError(ctx, fc) {
10194 ec.Errorf(ctx, "must not be null")
10195 }
10196 return graphql.Null
10197 }
10198 res := resTmp.(string)
10199 fc.Result = res
10200 return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
10201}
10202
10203func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10204 defer func() {
10205 if r := recover(); r != nil {
10206 ec.Error(ctx, ec.Recover(ctx, r))
10207 ret = graphql.Null
10208 }
10209 }()
10210 fc := &graphql.FieldContext{
10211 Object: "__Type",
10212 Field: field,
10213 Args: nil,
10214 IsMethod: true,
10215 }
10216
10217 ctx = graphql.WithFieldContext(ctx, fc)
10218 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10219 ctx = rctx // use context from middleware stack in children
10220 return obj.Name(), nil
10221 })
10222 if err != nil {
10223 ec.Error(ctx, err)
10224 return graphql.Null
10225 }
10226 if resTmp == nil {
10227 return graphql.Null
10228 }
10229 res := resTmp.(*string)
10230 fc.Result = res
10231 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10232}
10233
10234func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10235 defer func() {
10236 if r := recover(); r != nil {
10237 ec.Error(ctx, ec.Recover(ctx, r))
10238 ret = graphql.Null
10239 }
10240 }()
10241 fc := &graphql.FieldContext{
10242 Object: "__Type",
10243 Field: field,
10244 Args: nil,
10245 IsMethod: true,
10246 }
10247
10248 ctx = graphql.WithFieldContext(ctx, fc)
10249 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10250 ctx = rctx // use context from middleware stack in children
10251 return obj.Description(), nil
10252 })
10253 if err != nil {
10254 ec.Error(ctx, err)
10255 return graphql.Null
10256 }
10257 if resTmp == nil {
10258 return graphql.Null
10259 }
10260 res := resTmp.(string)
10261 fc.Result = res
10262 return ec.marshalOString2string(ctx, field.Selections, res)
10263}
10264
10265func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10266 defer func() {
10267 if r := recover(); r != nil {
10268 ec.Error(ctx, ec.Recover(ctx, r))
10269 ret = graphql.Null
10270 }
10271 }()
10272 fc := &graphql.FieldContext{
10273 Object: "__Type",
10274 Field: field,
10275 Args: nil,
10276 IsMethod: true,
10277 }
10278
10279 ctx = graphql.WithFieldContext(ctx, fc)
10280 rawArgs := field.ArgumentMap(ec.Variables)
10281 args, err := ec.field___Type_fields_args(ctx, rawArgs)
10282 if err != nil {
10283 ec.Error(ctx, err)
10284 return graphql.Null
10285 }
10286 fc.Args = args
10287 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10288 ctx = rctx // use context from middleware stack in children
10289 return obj.Fields(args["includeDeprecated"].(bool)), nil
10290 })
10291 if err != nil {
10292 ec.Error(ctx, err)
10293 return graphql.Null
10294 }
10295 if resTmp == nil {
10296 return graphql.Null
10297 }
10298 res := resTmp.([]introspection.Field)
10299 fc.Result = res
10300 return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
10301}
10302
10303func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10304 defer func() {
10305 if r := recover(); r != nil {
10306 ec.Error(ctx, ec.Recover(ctx, r))
10307 ret = graphql.Null
10308 }
10309 }()
10310 fc := &graphql.FieldContext{
10311 Object: "__Type",
10312 Field: field,
10313 Args: nil,
10314 IsMethod: true,
10315 }
10316
10317 ctx = graphql.WithFieldContext(ctx, fc)
10318 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10319 ctx = rctx // use context from middleware stack in children
10320 return obj.Interfaces(), nil
10321 })
10322 if err != nil {
10323 ec.Error(ctx, err)
10324 return graphql.Null
10325 }
10326 if resTmp == nil {
10327 return graphql.Null
10328 }
10329 res := resTmp.([]introspection.Type)
10330 fc.Result = res
10331 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10332}
10333
10334func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10335 defer func() {
10336 if r := recover(); r != nil {
10337 ec.Error(ctx, ec.Recover(ctx, r))
10338 ret = graphql.Null
10339 }
10340 }()
10341 fc := &graphql.FieldContext{
10342 Object: "__Type",
10343 Field: field,
10344 Args: nil,
10345 IsMethod: true,
10346 }
10347
10348 ctx = graphql.WithFieldContext(ctx, fc)
10349 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10350 ctx = rctx // use context from middleware stack in children
10351 return obj.PossibleTypes(), nil
10352 })
10353 if err != nil {
10354 ec.Error(ctx, err)
10355 return graphql.Null
10356 }
10357 if resTmp == nil {
10358 return graphql.Null
10359 }
10360 res := resTmp.([]introspection.Type)
10361 fc.Result = res
10362 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10363}
10364
10365func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10366 defer func() {
10367 if r := recover(); r != nil {
10368 ec.Error(ctx, ec.Recover(ctx, r))
10369 ret = graphql.Null
10370 }
10371 }()
10372 fc := &graphql.FieldContext{
10373 Object: "__Type",
10374 Field: field,
10375 Args: nil,
10376 IsMethod: true,
10377 }
10378
10379 ctx = graphql.WithFieldContext(ctx, fc)
10380 rawArgs := field.ArgumentMap(ec.Variables)
10381 args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
10382 if err != nil {
10383 ec.Error(ctx, err)
10384 return graphql.Null
10385 }
10386 fc.Args = args
10387 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10388 ctx = rctx // use context from middleware stack in children
10389 return obj.EnumValues(args["includeDeprecated"].(bool)), nil
10390 })
10391 if err != nil {
10392 ec.Error(ctx, err)
10393 return graphql.Null
10394 }
10395 if resTmp == nil {
10396 return graphql.Null
10397 }
10398 res := resTmp.([]introspection.EnumValue)
10399 fc.Result = res
10400 return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
10401}
10402
10403func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10404 defer func() {
10405 if r := recover(); r != nil {
10406 ec.Error(ctx, ec.Recover(ctx, r))
10407 ret = graphql.Null
10408 }
10409 }()
10410 fc := &graphql.FieldContext{
10411 Object: "__Type",
10412 Field: field,
10413 Args: nil,
10414 IsMethod: true,
10415 }
10416
10417 ctx = graphql.WithFieldContext(ctx, fc)
10418 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10419 ctx = rctx // use context from middleware stack in children
10420 return obj.InputFields(), nil
10421 })
10422 if err != nil {
10423 ec.Error(ctx, err)
10424 return graphql.Null
10425 }
10426 if resTmp == nil {
10427 return graphql.Null
10428 }
10429 res := resTmp.([]introspection.InputValue)
10430 fc.Result = res
10431 return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
10432}
10433
10434func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10435 defer func() {
10436 if r := recover(); r != nil {
10437 ec.Error(ctx, ec.Recover(ctx, r))
10438 ret = graphql.Null
10439 }
10440 }()
10441 fc := &graphql.FieldContext{
10442 Object: "__Type",
10443 Field: field,
10444 Args: nil,
10445 IsMethod: true,
10446 }
10447
10448 ctx = graphql.WithFieldContext(ctx, fc)
10449 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10450 ctx = rctx // use context from middleware stack in children
10451 return obj.OfType(), nil
10452 })
10453 if err != nil {
10454 ec.Error(ctx, err)
10455 return graphql.Null
10456 }
10457 if resTmp == nil {
10458 return graphql.Null
10459 }
10460 res := resTmp.(*introspection.Type)
10461 fc.Result = res
10462 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10463}
10464
10465// endregion **************************** field.gotpl *****************************
10466
10467// region **************************** input.gotpl *****************************
10468
10469func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
10470 var it models.AddCommentInput
10471 var asMap = obj.(map[string]interface{})
10472
10473 for k, v := range asMap {
10474 switch k {
10475 case "clientMutationId":
10476 var err error
10477 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10478 if err != nil {
10479 return it, err
10480 }
10481 case "repoRef":
10482 var err error
10483 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10484 if err != nil {
10485 return it, err
10486 }
10487 case "prefix":
10488 var err error
10489 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10490 if err != nil {
10491 return it, err
10492 }
10493 case "message":
10494 var err error
10495 it.Message, err = ec.unmarshalNString2string(ctx, v)
10496 if err != nil {
10497 return it, err
10498 }
10499 case "files":
10500 var err error
10501 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
10502 if err != nil {
10503 return it, err
10504 }
10505 }
10506 }
10507
10508 return it, nil
10509}
10510
10511func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
10512 var it models.ChangeLabelInput
10513 var asMap = obj.(map[string]interface{})
10514
10515 for k, v := range asMap {
10516 switch k {
10517 case "clientMutationId":
10518 var err error
10519 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10520 if err != nil {
10521 return it, err
10522 }
10523 case "repoRef":
10524 var err error
10525 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10526 if err != nil {
10527 return it, err
10528 }
10529 case "prefix":
10530 var err error
10531 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10532 if err != nil {
10533 return it, err
10534 }
10535 case "added":
10536 var err error
10537 it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10538 if err != nil {
10539 return it, err
10540 }
10541 case "Removed":
10542 var err error
10543 it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10544 if err != nil {
10545 return it, err
10546 }
10547 }
10548 }
10549
10550 return it, nil
10551}
10552
10553func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
10554 var it models.CloseBugInput
10555 var asMap = obj.(map[string]interface{})
10556
10557 for k, v := range asMap {
10558 switch k {
10559 case "clientMutationId":
10560 var err error
10561 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10562 if err != nil {
10563 return it, err
10564 }
10565 case "repoRef":
10566 var err error
10567 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10568 if err != nil {
10569 return it, err
10570 }
10571 case "prefix":
10572 var err error
10573 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10574 if err != nil {
10575 return it, err
10576 }
10577 }
10578 }
10579
10580 return it, nil
10581}
10582
10583func (ec *executionContext) unmarshalInputCommitInput(ctx context.Context, obj interface{}) (models.CommitInput, error) {
10584 var it models.CommitInput
10585 var asMap = obj.(map[string]interface{})
10586
10587 for k, v := range asMap {
10588 switch k {
10589 case "clientMutationId":
10590 var err error
10591 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10592 if err != nil {
10593 return it, err
10594 }
10595 case "id":
10596 var err error
10597 it.ID, err = ec.unmarshalNTxId2string(ctx, v)
10598 if err != nil {
10599 return it, err
10600 }
10601 }
10602 }
10603
10604 return it, nil
10605}
10606
10607func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
10608 var it models.NewBugInput
10609 var asMap = obj.(map[string]interface{})
10610
10611 for k, v := range asMap {
10612 switch k {
10613 case "clientMutationId":
10614 var err error
10615 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10616 if err != nil {
10617 return it, err
10618 }
10619 case "repoRef":
10620 var err error
10621 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10622 if err != nil {
10623 return it, err
10624 }
10625 case "title":
10626 var err error
10627 it.Title, err = ec.unmarshalNString2string(ctx, v)
10628 if err != nil {
10629 return it, err
10630 }
10631 case "message":
10632 var err error
10633 it.Message, err = ec.unmarshalNString2string(ctx, v)
10634 if err != nil {
10635 return it, err
10636 }
10637 case "files":
10638 var err error
10639 it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
10640 if err != nil {
10641 return it, err
10642 }
10643 }
10644 }
10645
10646 return it, nil
10647}
10648
10649func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
10650 var it models.OpenBugInput
10651 var asMap = obj.(map[string]interface{})
10652
10653 for k, v := range asMap {
10654 switch k {
10655 case "clientMutationId":
10656 var err error
10657 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10658 if err != nil {
10659 return it, err
10660 }
10661 case "repoRef":
10662 var err error
10663 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10664 if err != nil {
10665 return it, err
10666 }
10667 case "prefix":
10668 var err error
10669 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10670 if err != nil {
10671 return it, err
10672 }
10673 }
10674 }
10675
10676 return it, nil
10677}
10678
10679func (ec *executionContext) unmarshalInputRollbackInput(ctx context.Context, obj interface{}) (models.RollbackInput, error) {
10680 var it models.RollbackInput
10681 var asMap = obj.(map[string]interface{})
10682
10683 for k, v := range asMap {
10684 switch k {
10685 case "clientMutationId":
10686 var err error
10687 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10688 if err != nil {
10689 return it, err
10690 }
10691 case "id":
10692 var err error
10693 it.ID, err = ec.unmarshalNTxId2string(ctx, v)
10694 if err != nil {
10695 return it, err
10696 }
10697 }
10698 }
10699
10700 return it, nil
10701}
10702
10703func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
10704 var it models.SetTitleInput
10705 var asMap = obj.(map[string]interface{})
10706
10707 for k, v := range asMap {
10708 switch k {
10709 case "clientMutationId":
10710 var err error
10711 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10712 if err != nil {
10713 return it, err
10714 }
10715 case "repoRef":
10716 var err error
10717 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10718 if err != nil {
10719 return it, err
10720 }
10721 case "prefix":
10722 var err error
10723 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10724 if err != nil {
10725 return it, err
10726 }
10727 case "title":
10728 var err error
10729 it.Title, err = ec.unmarshalNString2string(ctx, v)
10730 if err != nil {
10731 return it, err
10732 }
10733 }
10734 }
10735
10736 return it, nil
10737}
10738
10739func (ec *executionContext) unmarshalInputStartTransactionInput(ctx context.Context, obj interface{}) (models.StartTransactionInput, error) {
10740 var it models.StartTransactionInput
10741 var asMap = obj.(map[string]interface{})
10742
10743 for k, v := range asMap {
10744 switch k {
10745 case "clientMutationId":
10746 var err error
10747 it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10748 if err != nil {
10749 return it, err
10750 }
10751 case "repoRef":
10752 var err error
10753 it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10754 if err != nil {
10755 return it, err
10756 }
10757 case "prefix":
10758 var err error
10759 it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10760 if err != nil {
10761 return it, err
10762 }
10763 }
10764 }
10765
10766 return it, nil
10767}
10768
10769// endregion **************************** input.gotpl *****************************
10770
10771// region ************************** interface.gotpl ***************************
10772
10773func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj models.Authored) graphql.Marshaler {
10774 switch obj := (obj).(type) {
10775 case nil:
10776 return graphql.Null
10777 case bug.Comment:
10778 return ec._Comment(ctx, sel, &obj)
10779 case *bug.Comment:
10780 if obj == nil {
10781 return graphql.Null
10782 }
10783 return ec._Comment(ctx, sel, obj)
10784 case models.BugWrapper:
10785 if obj == nil {
10786 return graphql.Null
10787 }
10788 return ec._Bug(ctx, sel, obj)
10789 case *bug.CreateOperation:
10790 if obj == nil {
10791 return graphql.Null
10792 }
10793 return ec._CreateOperation(ctx, sel, obj)
10794 case *bug.SetTitleOperation:
10795 if obj == nil {
10796 return graphql.Null
10797 }
10798 return ec._SetTitleOperation(ctx, sel, obj)
10799 case *bug.AddCommentOperation:
10800 if obj == nil {
10801 return graphql.Null
10802 }
10803 return ec._AddCommentOperation(ctx, sel, obj)
10804 case *bug.EditCommentOperation:
10805 if obj == nil {
10806 return graphql.Null
10807 }
10808 return ec._EditCommentOperation(ctx, sel, obj)
10809 case *bug.SetStatusOperation:
10810 if obj == nil {
10811 return graphql.Null
10812 }
10813 return ec._SetStatusOperation(ctx, sel, obj)
10814 case *bug.LabelChangeOperation:
10815 if obj == nil {
10816 return graphql.Null
10817 }
10818 return ec._LabelChangeOperation(ctx, sel, obj)
10819 case *bug.CreateTimelineItem:
10820 if obj == nil {
10821 return graphql.Null
10822 }
10823 return ec._CreateTimelineItem(ctx, sel, obj)
10824 case *bug.AddCommentTimelineItem:
10825 if obj == nil {
10826 return graphql.Null
10827 }
10828 return ec._AddCommentTimelineItem(ctx, sel, obj)
10829 case *bug.LabelChangeTimelineItem:
10830 if obj == nil {
10831 return graphql.Null
10832 }
10833 return ec._LabelChangeTimelineItem(ctx, sel, obj)
10834 case *bug.SetStatusTimelineItem:
10835 if obj == nil {
10836 return graphql.Null
10837 }
10838 return ec._SetStatusTimelineItem(ctx, sel, obj)
10839 case *bug.SetTitleTimelineItem:
10840 if obj == nil {
10841 return graphql.Null
10842 }
10843 return ec._SetTitleTimelineItem(ctx, sel, obj)
10844 default:
10845 panic(fmt.Errorf("unexpected type %T", obj))
10846 }
10847}
10848
10849func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj bug.Operation) graphql.Marshaler {
10850 switch obj := (obj).(type) {
10851 case nil:
10852 return graphql.Null
10853 case *bug.CreateOperation:
10854 if obj == nil {
10855 return graphql.Null
10856 }
10857 return ec._CreateOperation(ctx, sel, obj)
10858 case *bug.SetTitleOperation:
10859 if obj == nil {
10860 return graphql.Null
10861 }
10862 return ec._SetTitleOperation(ctx, sel, obj)
10863 case *bug.AddCommentOperation:
10864 if obj == nil {
10865 return graphql.Null
10866 }
10867 return ec._AddCommentOperation(ctx, sel, obj)
10868 case *bug.EditCommentOperation:
10869 if obj == nil {
10870 return graphql.Null
10871 }
10872 return ec._EditCommentOperation(ctx, sel, obj)
10873 case *bug.SetStatusOperation:
10874 if obj == nil {
10875 return graphql.Null
10876 }
10877 return ec._SetStatusOperation(ctx, sel, obj)
10878 case *bug.LabelChangeOperation:
10879 if obj == nil {
10880 return graphql.Null
10881 }
10882 return ec._LabelChangeOperation(ctx, sel, obj)
10883 default:
10884 panic(fmt.Errorf("unexpected type %T", obj))
10885 }
10886}
10887
10888func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
10889 switch obj := (obj).(type) {
10890 case nil:
10891 return graphql.Null
10892 case *bug.CreateTimelineItem:
10893 if obj == nil {
10894 return graphql.Null
10895 }
10896 return ec._CreateTimelineItem(ctx, sel, obj)
10897 case *bug.AddCommentTimelineItem:
10898 if obj == nil {
10899 return graphql.Null
10900 }
10901 return ec._AddCommentTimelineItem(ctx, sel, obj)
10902 case bug.LabelChangeTimelineItem:
10903 return ec._LabelChangeTimelineItem(ctx, sel, &obj)
10904 case *bug.LabelChangeTimelineItem:
10905 if obj == nil {
10906 return graphql.Null
10907 }
10908 return ec._LabelChangeTimelineItem(ctx, sel, obj)
10909 case bug.SetStatusTimelineItem:
10910 return ec._SetStatusTimelineItem(ctx, sel, &obj)
10911 case *bug.SetStatusTimelineItem:
10912 if obj == nil {
10913 return graphql.Null
10914 }
10915 return ec._SetStatusTimelineItem(ctx, sel, obj)
10916 case bug.SetTitleTimelineItem:
10917 return ec._SetTitleTimelineItem(ctx, sel, &obj)
10918 case *bug.SetTitleTimelineItem:
10919 if obj == nil {
10920 return graphql.Null
10921 }
10922 return ec._SetTitleTimelineItem(ctx, sel, obj)
10923 default:
10924 panic(fmt.Errorf("unexpected type %T", obj))
10925 }
10926}
10927
10928// endregion ************************** interface.gotpl ***************************
10929
10930// region **************************** object.gotpl ****************************
10931
10932var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
10933
10934func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
10935 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
10936
10937 out := graphql.NewFieldSet(fields)
10938 var invalids uint32
10939 for i, field := range fields {
10940 switch field.Name {
10941 case "__typename":
10942 out.Values[i] = graphql.MarshalString("AddCommentOperation")
10943 case "id":
10944 field := field
10945 out.Concurrently(i, func() (res graphql.Marshaler) {
10946 defer func() {
10947 if r := recover(); r != nil {
10948 ec.Error(ctx, ec.Recover(ctx, r))
10949 }
10950 }()
10951 res = ec._AddCommentOperation_id(ctx, field, obj)
10952 if res == graphql.Null {
10953 atomic.AddUint32(&invalids, 1)
10954 }
10955 return res
10956 })
10957 case "author":
10958 field := field
10959 out.Concurrently(i, func() (res graphql.Marshaler) {
10960 defer func() {
10961 if r := recover(); r != nil {
10962 ec.Error(ctx, ec.Recover(ctx, r))
10963 }
10964 }()
10965 res = ec._AddCommentOperation_author(ctx, field, obj)
10966 if res == graphql.Null {
10967 atomic.AddUint32(&invalids, 1)
10968 }
10969 return res
10970 })
10971 case "date":
10972 field := field
10973 out.Concurrently(i, func() (res graphql.Marshaler) {
10974 defer func() {
10975 if r := recover(); r != nil {
10976 ec.Error(ctx, ec.Recover(ctx, r))
10977 }
10978 }()
10979 res = ec._AddCommentOperation_date(ctx, field, obj)
10980 if res == graphql.Null {
10981 atomic.AddUint32(&invalids, 1)
10982 }
10983 return res
10984 })
10985 case "message":
10986 out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
10987 if out.Values[i] == graphql.Null {
10988 atomic.AddUint32(&invalids, 1)
10989 }
10990 case "files":
10991 out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
10992 if out.Values[i] == graphql.Null {
10993 atomic.AddUint32(&invalids, 1)
10994 }
10995 default:
10996 panic("unknown field " + strconv.Quote(field.Name))
10997 }
10998 }
10999 out.Dispatch()
11000 if invalids > 0 {
11001 return graphql.Null
11002 }
11003 return out
11004}
11005
11006var addCommentPayloadImplementors = []string{"AddCommentPayload"}
11007
11008func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
11009 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
11010
11011 out := graphql.NewFieldSet(fields)
11012 var invalids uint32
11013 for i, field := range fields {
11014 switch field.Name {
11015 case "__typename":
11016 out.Values[i] = graphql.MarshalString("AddCommentPayload")
11017 case "clientMutationId":
11018 out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
11019 case "bug":
11020 out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
11021 if out.Values[i] == graphql.Null {
11022 invalids++
11023 }
11024 case "operation":
11025 out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
11026 if out.Values[i] == graphql.Null {
11027 invalids++
11028 }
11029 default:
11030 panic("unknown field " + strconv.Quote(field.Name))
11031 }
11032 }
11033 out.Dispatch()
11034 if invalids > 0 {
11035 return graphql.Null
11036 }
11037 return out
11038}
11039
11040var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
11041
11042func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
11043 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
11044
11045 out := graphql.NewFieldSet(fields)
11046 var invalids uint32
11047 for i, field := range fields {
11048 switch field.Name {
11049 case "__typename":
11050 out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
11051 case "id":
11052 field := field
11053 out.Concurrently(i, func() (res graphql.Marshaler) {
11054 defer func() {
11055 if r := recover(); r != nil {
11056 ec.Error(ctx, ec.Recover(ctx, r))
11057 }
11058 }()
11059 res = ec._AddCommentTimelineItem_id(ctx, field, obj)
11060 if res == graphql.Null {
11061 atomic.AddUint32(&invalids, 1)
11062 }
11063 return res
11064 })
11065 case "author":
11066 field := field
11067 out.Concurrently(i, func() (res graphql.Marshaler) {
11068 defer func() {
11069 if r := recover(); r != nil {
11070 ec.Error(ctx, ec.Recover(ctx, r))
11071 }
11072 }()
11073 res = ec._AddCommentTimelineItem_author(ctx, field, obj)
11074 if res == graphql.Null {
11075 atomic.AddUint32(&invalids, 1)
11076 }
11077 return res
11078 })
11079 case "message":
11080 out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
11081 if out.Values[i] == graphql.Null {
11082 atomic.AddUint32(&invalids, 1)
11083 }
11084 case "messageIsEmpty":
11085 out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
11086 if out.Values[i] == graphql.Null {
11087 atomic.AddUint32(&invalids, 1)
11088 }
11089 case "files":
11090 out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
11091 if out.Values[i] == graphql.Null {
11092 atomic.AddUint32(&invalids, 1)
11093 }
11094 case "createdAt":
11095 field := field
11096 out.Concurrently(i, func() (res graphql.Marshaler) {
11097 defer func() {
11098 if r := recover(); r != nil {
11099 ec.Error(ctx, ec.Recover(ctx, r))
11100 }
11101 }()
11102 res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
11103 if res == graphql.Null {
11104 atomic.AddUint32(&invalids, 1)
11105 }
11106 return res
11107 })
11108 case "lastEdit":
11109 field := field
11110 out.Concurrently(i, func() (res graphql.Marshaler) {
11111 defer func() {
11112 if r := recover(); r != nil {
11113 ec.Error(ctx, ec.Recover(ctx, r))
11114 }
11115 }()
11116 res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
11117 if res == graphql.Null {
11118 atomic.AddUint32(&invalids, 1)
11119 }
11120 return res
11121 })
11122 case "edited":
11123 out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
11124 if out.Values[i] == graphql.Null {
11125 atomic.AddUint32(&invalids, 1)
11126 }
11127 case "history":
11128 out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
11129 if out.Values[i] == graphql.Null {
11130 atomic.AddUint32(&invalids, 1)
11131 }
11132 default:
11133 panic("unknown field " + strconv.Quote(field.Name))
11134 }
11135 }
11136 out.Dispatch()
11137 if invalids > 0 {
11138 return graphql.Null
11139 }
11140 return out
11141}
11142
11143var bugImplementors = []string{"Bug", "Authored"}
11144
11145func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
11146 fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
11147
11148 out := graphql.NewFieldSet(fields)
11149 var invalids uint32
11150 for i, field := range fields {
11151 switch field.Name {
11152 case "__typename":
11153 out.Values[i] = graphql.MarshalString("Bug")
11154 case "id":
11155 field := field
11156 out.Concurrently(i, func() (res graphql.Marshaler) {
11157 defer func() {
11158 if r := recover(); r != nil {
11159 ec.Error(ctx, ec.Recover(ctx, r))
11160 }
11161 }()
11162 res = ec._Bug_id(ctx, field, obj)
11163 if res == graphql.Null {
11164 atomic.AddUint32(&invalids, 1)
11165 }
11166 return res
11167 })
11168 case "humanId":
11169 field := field
11170 out.Concurrently(i, func() (res graphql.Marshaler) {
11171 defer func() {
11172 if r := recover(); r != nil {
11173 ec.Error(ctx, ec.Recover(ctx, r))
11174 }
11175 }()
11176 res = ec._Bug_humanId(ctx, field, obj)
11177 if res == graphql.Null {
11178 atomic.AddUint32(&invalids, 1)
11179 }
11180 return res
11181 })
11182 case "status":
11183 field := field
11184 out.Concurrently(i, func() (res graphql.Marshaler) {
11185 defer func() {
11186 if r := recover(); r != nil {
11187 ec.Error(ctx, ec.Recover(ctx, r))
11188 }
11189 }()
11190 res = ec._Bug_status(ctx, field, obj)
11191 if res == graphql.Null {
11192 atomic.AddUint32(&invalids, 1)
11193 }
11194 return res
11195 })
11196 case "title":
11197 out.Values[i] = ec._Bug_title(ctx, field, obj)
11198 if out.Values[i] == graphql.Null {
11199 atomic.AddUint32(&invalids, 1)
11200 }
11201 case "labels":
11202 out.Values[i] = ec._Bug_labels(ctx, field, obj)
11203 if out.Values[i] == graphql.Null {
11204 atomic.AddUint32(&invalids, 1)
11205 }
11206 case "author":
11207 out.Values[i] = ec._Bug_author(ctx, field, obj)
11208 if out.Values[i] == graphql.Null {
11209 atomic.AddUint32(&invalids, 1)
11210 }
11211 case "createdAt":
11212 out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
11213 if out.Values[i] == graphql.Null {
11214 atomic.AddUint32(&invalids, 1)
11215 }
11216 case "lastEdit":
11217 out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
11218 if out.Values[i] == graphql.Null {
11219 atomic.AddUint32(&invalids, 1)
11220 }
11221 case "actors":
11222 field := field
11223 out.Concurrently(i, func() (res graphql.Marshaler) {
11224 defer func() {
11225 if r := recover(); r != nil {
11226 ec.Error(ctx, ec.Recover(ctx, r))
11227 }
11228 }()
11229 res = ec._Bug_actors(ctx, field, obj)
11230 if res == graphql.Null {
11231 atomic.AddUint32(&invalids, 1)
11232 }
11233 return res
11234 })
11235 case "participants":
11236 field := field
11237 out.Concurrently(i, func() (res graphql.Marshaler) {
11238 defer func() {
11239 if r := recover(); r != nil {
11240 ec.Error(ctx, ec.Recover(ctx, r))
11241 }
11242 }()
11243 res = ec._Bug_participants(ctx, field, obj)
11244 if res == graphql.Null {
11245 atomic.AddUint32(&invalids, 1)
11246 }
11247 return res
11248 })
11249 case "comments":
11250 field := field
11251 out.Concurrently(i, func() (res graphql.Marshaler) {
11252 defer func() {
11253 if r := recover(); r != nil {
11254 ec.Error(ctx, ec.Recover(ctx, r))
11255 }
11256 }()
11257 res = ec._Bug_comments(ctx, field, obj)
11258 if res == graphql.Null {
11259 atomic.AddUint32(&invalids, 1)
11260 }
11261 return res
11262 })
11263 case "timeline":
11264 field := field
11265 out.Concurrently(i, func() (res graphql.Marshaler) {
11266 defer func() {
11267 if r := recover(); r != nil {
11268 ec.Error(ctx, ec.Recover(ctx, r))
11269 }
11270 }()
11271 res = ec._Bug_timeline(ctx, field, obj)
11272 if res == graphql.Null {
11273 atomic.AddUint32(&invalids, 1)
11274 }
11275 return res
11276 })
11277 case "operations":
11278 field := field
11279 out.Concurrently(i, func() (res graphql.Marshaler) {
11280 defer func() {
11281 if r := recover(); r != nil {
11282 ec.Error(ctx, ec.Recover(ctx, r))
11283 }
11284 }()
11285 res = ec._Bug_operations(ctx, field, obj)
11286 if res == graphql.Null {
11287 atomic.AddUint32(&invalids, 1)
11288 }
11289 return res
11290 })
11291 default:
11292 panic("unknown field " + strconv.Quote(field.Name))
11293 }
11294 }
11295 out.Dispatch()
11296 if invalids > 0 {
11297 return graphql.Null
11298 }
11299 return out
11300}
11301
11302var bugConnectionImplementors = []string{"BugConnection"}
11303
11304func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
11305 fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
11306
11307 out := graphql.NewFieldSet(fields)
11308 var invalids uint32
11309 for i, field := range fields {
11310 switch field.Name {
11311 case "__typename":
11312 out.Values[i] = graphql.MarshalString("BugConnection")
11313 case "edges":
11314 out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
11315 if out.Values[i] == graphql.Null {
11316 invalids++
11317 }
11318 case "nodes":
11319 out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
11320 if out.Values[i] == graphql.Null {
11321 invalids++
11322 }
11323 case "pageInfo":
11324 out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
11325 if out.Values[i] == graphql.Null {
11326 invalids++
11327 }
11328 case "totalCount":
11329 out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
11330 if out.Values[i] == graphql.Null {
11331 invalids++
11332 }
11333 default:
11334 panic("unknown field " + strconv.Quote(field.Name))
11335 }
11336 }
11337 out.Dispatch()
11338 if invalids > 0 {
11339 return graphql.Null
11340 }
11341 return out
11342}
11343
11344var bugEdgeImplementors = []string{"BugEdge"}
11345
11346func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
11347 fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
11348
11349 out := graphql.NewFieldSet(fields)
11350 var invalids uint32
11351 for i, field := range fields {
11352 switch field.Name {
11353 case "__typename":
11354 out.Values[i] = graphql.MarshalString("BugEdge")
11355 case "cursor":
11356 out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
11357 if out.Values[i] == graphql.Null {
11358 invalids++
11359 }
11360 case "node":
11361 out.Values[i] = ec._BugEdge_node(ctx, field, obj)
11362 if out.Values[i] == graphql.Null {
11363 invalids++
11364 }
11365 default:
11366 panic("unknown field " + strconv.Quote(field.Name))
11367 }
11368 }
11369 out.Dispatch()
11370 if invalids > 0 {
11371 return graphql.Null
11372 }
11373 return out
11374}
11375
11376var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
11377
11378func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
11379 fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
11380
11381 out := graphql.NewFieldSet(fields)
11382 var invalids uint32
11383 for i, field := range fields {
11384 switch field.Name {
11385 case "__typename":
11386 out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
11387 case "clientMutationId":
11388 out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
11389 case "bug":
11390 out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
11391 if out.Values[i] == graphql.Null {
11392 invalids++
11393 }
11394 case "operation":
11395 out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
11396 if out.Values[i] == graphql.Null {
11397 invalids++
11398 }
11399 case "results":
11400 out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
11401 if out.Values[i] == graphql.Null {
11402 invalids++
11403 }
11404 default:
11405 panic("unknown field " + strconv.Quote(field.Name))
11406 }
11407 }
11408 out.Dispatch()
11409 if invalids > 0 {
11410 return graphql.Null
11411 }
11412 return out
11413}
11414
11415var closeBugPayloadImplementors = []string{"CloseBugPayload"}
11416
11417func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
11418 fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
11419
11420 out := graphql.NewFieldSet(fields)
11421 var invalids uint32
11422 for i, field := range fields {
11423 switch field.Name {
11424 case "__typename":
11425 out.Values[i] = graphql.MarshalString("CloseBugPayload")
11426 case "clientMutationId":
11427 out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
11428 case "bug":
11429 out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
11430 if out.Values[i] == graphql.Null {
11431 invalids++
11432 }
11433 case "operation":
11434 out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
11435 if out.Values[i] == graphql.Null {
11436 invalids++
11437 }
11438 default:
11439 panic("unknown field " + strconv.Quote(field.Name))
11440 }
11441 }
11442 out.Dispatch()
11443 if invalids > 0 {
11444 return graphql.Null
11445 }
11446 return out
11447}
11448
11449var colorImplementors = []string{"Color"}
11450
11451func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
11452 fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
11453
11454 out := graphql.NewFieldSet(fields)
11455 var invalids uint32
11456 for i, field := range fields {
11457 switch field.Name {
11458 case "__typename":
11459 out.Values[i] = graphql.MarshalString("Color")
11460 case "R":
11461 field := field
11462 out.Concurrently(i, func() (res graphql.Marshaler) {
11463 defer func() {
11464 if r := recover(); r != nil {
11465 ec.Error(ctx, ec.Recover(ctx, r))
11466 }
11467 }()
11468 res = ec._Color_R(ctx, field, obj)
11469 if res == graphql.Null {
11470 atomic.AddUint32(&invalids, 1)
11471 }
11472 return res
11473 })
11474 case "G":
11475 field := field
11476 out.Concurrently(i, func() (res graphql.Marshaler) {
11477 defer func() {
11478 if r := recover(); r != nil {
11479 ec.Error(ctx, ec.Recover(ctx, r))
11480 }
11481 }()
11482 res = ec._Color_G(ctx, field, obj)
11483 if res == graphql.Null {
11484 atomic.AddUint32(&invalids, 1)
11485 }
11486 return res
11487 })
11488 case "B":
11489 field := field
11490 out.Concurrently(i, func() (res graphql.Marshaler) {
11491 defer func() {
11492 if r := recover(); r != nil {
11493 ec.Error(ctx, ec.Recover(ctx, r))
11494 }
11495 }()
11496 res = ec._Color_B(ctx, field, obj)
11497 if res == graphql.Null {
11498 atomic.AddUint32(&invalids, 1)
11499 }
11500 return res
11501 })
11502 default:
11503 panic("unknown field " + strconv.Quote(field.Name))
11504 }
11505 }
11506 out.Dispatch()
11507 if invalids > 0 {
11508 return graphql.Null
11509 }
11510 return out
11511}
11512
11513var commentImplementors = []string{"Comment", "Authored"}
11514
11515func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
11516 fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
11517
11518 out := graphql.NewFieldSet(fields)
11519 var invalids uint32
11520 for i, field := range fields {
11521 switch field.Name {
11522 case "__typename":
11523 out.Values[i] = graphql.MarshalString("Comment")
11524 case "author":
11525 field := field
11526 out.Concurrently(i, func() (res graphql.Marshaler) {
11527 defer func() {
11528 if r := recover(); r != nil {
11529 ec.Error(ctx, ec.Recover(ctx, r))
11530 }
11531 }()
11532 res = ec._Comment_author(ctx, field, obj)
11533 if res == graphql.Null {
11534 atomic.AddUint32(&invalids, 1)
11535 }
11536 return res
11537 })
11538 case "message":
11539 out.Values[i] = ec._Comment_message(ctx, field, obj)
11540 if out.Values[i] == graphql.Null {
11541 atomic.AddUint32(&invalids, 1)
11542 }
11543 case "files":
11544 out.Values[i] = ec._Comment_files(ctx, field, obj)
11545 if out.Values[i] == graphql.Null {
11546 atomic.AddUint32(&invalids, 1)
11547 }
11548 default:
11549 panic("unknown field " + strconv.Quote(field.Name))
11550 }
11551 }
11552 out.Dispatch()
11553 if invalids > 0 {
11554 return graphql.Null
11555 }
11556 return out
11557}
11558
11559var commentConnectionImplementors = []string{"CommentConnection"}
11560
11561func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
11562 fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
11563
11564 out := graphql.NewFieldSet(fields)
11565 var invalids uint32
11566 for i, field := range fields {
11567 switch field.Name {
11568 case "__typename":
11569 out.Values[i] = graphql.MarshalString("CommentConnection")
11570 case "edges":
11571 out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
11572 if out.Values[i] == graphql.Null {
11573 invalids++
11574 }
11575 case "nodes":
11576 out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
11577 if out.Values[i] == graphql.Null {
11578 invalids++
11579 }
11580 case "pageInfo":
11581 out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
11582 if out.Values[i] == graphql.Null {
11583 invalids++
11584 }
11585 case "totalCount":
11586 out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
11587 if out.Values[i] == graphql.Null {
11588 invalids++
11589 }
11590 default:
11591 panic("unknown field " + strconv.Quote(field.Name))
11592 }
11593 }
11594 out.Dispatch()
11595 if invalids > 0 {
11596 return graphql.Null
11597 }
11598 return out
11599}
11600
11601var commentEdgeImplementors = []string{"CommentEdge"}
11602
11603func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
11604 fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
11605
11606 out := graphql.NewFieldSet(fields)
11607 var invalids uint32
11608 for i, field := range fields {
11609 switch field.Name {
11610 case "__typename":
11611 out.Values[i] = graphql.MarshalString("CommentEdge")
11612 case "cursor":
11613 out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
11614 if out.Values[i] == graphql.Null {
11615 invalids++
11616 }
11617 case "node":
11618 out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
11619 if out.Values[i] == graphql.Null {
11620 invalids++
11621 }
11622 default:
11623 panic("unknown field " + strconv.Quote(field.Name))
11624 }
11625 }
11626 out.Dispatch()
11627 if invalids > 0 {
11628 return graphql.Null
11629 }
11630 return out
11631}
11632
11633var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
11634
11635func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
11636 fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
11637
11638 out := graphql.NewFieldSet(fields)
11639 var invalids uint32
11640 for i, field := range fields {
11641 switch field.Name {
11642 case "__typename":
11643 out.Values[i] = graphql.MarshalString("CommentHistoryStep")
11644 case "message":
11645 out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
11646 if out.Values[i] == graphql.Null {
11647 atomic.AddUint32(&invalids, 1)
11648 }
11649 case "date":
11650 field := field
11651 out.Concurrently(i, func() (res graphql.Marshaler) {
11652 defer func() {
11653 if r := recover(); r != nil {
11654 ec.Error(ctx, ec.Recover(ctx, r))
11655 }
11656 }()
11657 res = ec._CommentHistoryStep_date(ctx, field, obj)
11658 if res == graphql.Null {
11659 atomic.AddUint32(&invalids, 1)
11660 }
11661 return res
11662 })
11663 default:
11664 panic("unknown field " + strconv.Quote(field.Name))
11665 }
11666 }
11667 out.Dispatch()
11668 if invalids > 0 {
11669 return graphql.Null
11670 }
11671 return out
11672}
11673
11674var commitPayloadImplementors = []string{"CommitPayload"}
11675
11676func (ec *executionContext) _CommitPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitPayload) graphql.Marshaler {
11677 fields := graphql.CollectFields(ec.OperationContext, sel, commitPayloadImplementors)
11678
11679 out := graphql.NewFieldSet(fields)
11680 var invalids uint32
11681 for i, field := range fields {
11682 switch field.Name {
11683 case "__typename":
11684 out.Values[i] = graphql.MarshalString("CommitPayload")
11685 case "clientMutationId":
11686 out.Values[i] = ec._CommitPayload_clientMutationId(ctx, field, obj)
11687 case "id":
11688 out.Values[i] = ec._CommitPayload_id(ctx, field, obj)
11689 if out.Values[i] == graphql.Null {
11690 invalids++
11691 }
11692 case "bug":
11693 out.Values[i] = ec._CommitPayload_bug(ctx, field, obj)
11694 if out.Values[i] == graphql.Null {
11695 invalids++
11696 }
11697 default:
11698 panic("unknown field " + strconv.Quote(field.Name))
11699 }
11700 }
11701 out.Dispatch()
11702 if invalids > 0 {
11703 return graphql.Null
11704 }
11705 return out
11706}
11707
11708var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
11709
11710func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
11711 fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
11712
11713 out := graphql.NewFieldSet(fields)
11714 var invalids uint32
11715 for i, field := range fields {
11716 switch field.Name {
11717 case "__typename":
11718 out.Values[i] = graphql.MarshalString("CreateOperation")
11719 case "id":
11720 field := field
11721 out.Concurrently(i, func() (res graphql.Marshaler) {
11722 defer func() {
11723 if r := recover(); r != nil {
11724 ec.Error(ctx, ec.Recover(ctx, r))
11725 }
11726 }()
11727 res = ec._CreateOperation_id(ctx, field, obj)
11728 if res == graphql.Null {
11729 atomic.AddUint32(&invalids, 1)
11730 }
11731 return res
11732 })
11733 case "author":
11734 field := field
11735 out.Concurrently(i, func() (res graphql.Marshaler) {
11736 defer func() {
11737 if r := recover(); r != nil {
11738 ec.Error(ctx, ec.Recover(ctx, r))
11739 }
11740 }()
11741 res = ec._CreateOperation_author(ctx, field, obj)
11742 if res == graphql.Null {
11743 atomic.AddUint32(&invalids, 1)
11744 }
11745 return res
11746 })
11747 case "date":
11748 field := field
11749 out.Concurrently(i, func() (res graphql.Marshaler) {
11750 defer func() {
11751 if r := recover(); r != nil {
11752 ec.Error(ctx, ec.Recover(ctx, r))
11753 }
11754 }()
11755 res = ec._CreateOperation_date(ctx, field, obj)
11756 if res == graphql.Null {
11757 atomic.AddUint32(&invalids, 1)
11758 }
11759 return res
11760 })
11761 case "title":
11762 out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
11763 if out.Values[i] == graphql.Null {
11764 atomic.AddUint32(&invalids, 1)
11765 }
11766 case "message":
11767 out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
11768 if out.Values[i] == graphql.Null {
11769 atomic.AddUint32(&invalids, 1)
11770 }
11771 case "files":
11772 out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
11773 if out.Values[i] == graphql.Null {
11774 atomic.AddUint32(&invalids, 1)
11775 }
11776 default:
11777 panic("unknown field " + strconv.Quote(field.Name))
11778 }
11779 }
11780 out.Dispatch()
11781 if invalids > 0 {
11782 return graphql.Null
11783 }
11784 return out
11785}
11786
11787var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
11788
11789func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
11790 fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
11791
11792 out := graphql.NewFieldSet(fields)
11793 var invalids uint32
11794 for i, field := range fields {
11795 switch field.Name {
11796 case "__typename":
11797 out.Values[i] = graphql.MarshalString("CreateTimelineItem")
11798 case "id":
11799 field := field
11800 out.Concurrently(i, func() (res graphql.Marshaler) {
11801 defer func() {
11802 if r := recover(); r != nil {
11803 ec.Error(ctx, ec.Recover(ctx, r))
11804 }
11805 }()
11806 res = ec._CreateTimelineItem_id(ctx, field, obj)
11807 if res == graphql.Null {
11808 atomic.AddUint32(&invalids, 1)
11809 }
11810 return res
11811 })
11812 case "author":
11813 field := field
11814 out.Concurrently(i, func() (res graphql.Marshaler) {
11815 defer func() {
11816 if r := recover(); r != nil {
11817 ec.Error(ctx, ec.Recover(ctx, r))
11818 }
11819 }()
11820 res = ec._CreateTimelineItem_author(ctx, field, obj)
11821 if res == graphql.Null {
11822 atomic.AddUint32(&invalids, 1)
11823 }
11824 return res
11825 })
11826 case "message":
11827 out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
11828 if out.Values[i] == graphql.Null {
11829 atomic.AddUint32(&invalids, 1)
11830 }
11831 case "messageIsEmpty":
11832 out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
11833 if out.Values[i] == graphql.Null {
11834 atomic.AddUint32(&invalids, 1)
11835 }
11836 case "files":
11837 out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
11838 if out.Values[i] == graphql.Null {
11839 atomic.AddUint32(&invalids, 1)
11840 }
11841 case "createdAt":
11842 field := field
11843 out.Concurrently(i, func() (res graphql.Marshaler) {
11844 defer func() {
11845 if r := recover(); r != nil {
11846 ec.Error(ctx, ec.Recover(ctx, r))
11847 }
11848 }()
11849 res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
11850 if res == graphql.Null {
11851 atomic.AddUint32(&invalids, 1)
11852 }
11853 return res
11854 })
11855 case "lastEdit":
11856 field := field
11857 out.Concurrently(i, func() (res graphql.Marshaler) {
11858 defer func() {
11859 if r := recover(); r != nil {
11860 ec.Error(ctx, ec.Recover(ctx, r))
11861 }
11862 }()
11863 res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
11864 if res == graphql.Null {
11865 atomic.AddUint32(&invalids, 1)
11866 }
11867 return res
11868 })
11869 case "edited":
11870 out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
11871 if out.Values[i] == graphql.Null {
11872 atomic.AddUint32(&invalids, 1)
11873 }
11874 case "history":
11875 out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
11876 if out.Values[i] == graphql.Null {
11877 atomic.AddUint32(&invalids, 1)
11878 }
11879 default:
11880 panic("unknown field " + strconv.Quote(field.Name))
11881 }
11882 }
11883 out.Dispatch()
11884 if invalids > 0 {
11885 return graphql.Null
11886 }
11887 return out
11888}
11889
11890var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
11891
11892func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
11893 fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
11894
11895 out := graphql.NewFieldSet(fields)
11896 var invalids uint32
11897 for i, field := range fields {
11898 switch field.Name {
11899 case "__typename":
11900 out.Values[i] = graphql.MarshalString("EditCommentOperation")
11901 case "id":
11902 field := field
11903 out.Concurrently(i, func() (res graphql.Marshaler) {
11904 defer func() {
11905 if r := recover(); r != nil {
11906 ec.Error(ctx, ec.Recover(ctx, r))
11907 }
11908 }()
11909 res = ec._EditCommentOperation_id(ctx, field, obj)
11910 if res == graphql.Null {
11911 atomic.AddUint32(&invalids, 1)
11912 }
11913 return res
11914 })
11915 case "author":
11916 field := field
11917 out.Concurrently(i, func() (res graphql.Marshaler) {
11918 defer func() {
11919 if r := recover(); r != nil {
11920 ec.Error(ctx, ec.Recover(ctx, r))
11921 }
11922 }()
11923 res = ec._EditCommentOperation_author(ctx, field, obj)
11924 if res == graphql.Null {
11925 atomic.AddUint32(&invalids, 1)
11926 }
11927 return res
11928 })
11929 case "date":
11930 field := field
11931 out.Concurrently(i, func() (res graphql.Marshaler) {
11932 defer func() {
11933 if r := recover(); r != nil {
11934 ec.Error(ctx, ec.Recover(ctx, r))
11935 }
11936 }()
11937 res = ec._EditCommentOperation_date(ctx, field, obj)
11938 if res == graphql.Null {
11939 atomic.AddUint32(&invalids, 1)
11940 }
11941 return res
11942 })
11943 case "target":
11944 field := field
11945 out.Concurrently(i, func() (res graphql.Marshaler) {
11946 defer func() {
11947 if r := recover(); r != nil {
11948 ec.Error(ctx, ec.Recover(ctx, r))
11949 }
11950 }()
11951 res = ec._EditCommentOperation_target(ctx, field, obj)
11952 if res == graphql.Null {
11953 atomic.AddUint32(&invalids, 1)
11954 }
11955 return res
11956 })
11957 case "message":
11958 out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
11959 if out.Values[i] == graphql.Null {
11960 atomic.AddUint32(&invalids, 1)
11961 }
11962 case "files":
11963 out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
11964 if out.Values[i] == graphql.Null {
11965 atomic.AddUint32(&invalids, 1)
11966 }
11967 default:
11968 panic("unknown field " + strconv.Quote(field.Name))
11969 }
11970 }
11971 out.Dispatch()
11972 if invalids > 0 {
11973 return graphql.Null
11974 }
11975 return out
11976}
11977
11978var identityImplementors = []string{"Identity"}
11979
11980func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj models.IdentityWrapper) graphql.Marshaler {
11981 fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
11982
11983 out := graphql.NewFieldSet(fields)
11984 var invalids uint32
11985 for i, field := range fields {
11986 switch field.Name {
11987 case "__typename":
11988 out.Values[i] = graphql.MarshalString("Identity")
11989 case "id":
11990 field := field
11991 out.Concurrently(i, func() (res graphql.Marshaler) {
11992 defer func() {
11993 if r := recover(); r != nil {
11994 ec.Error(ctx, ec.Recover(ctx, r))
11995 }
11996 }()
11997 res = ec._Identity_id(ctx, field, obj)
11998 if res == graphql.Null {
11999 atomic.AddUint32(&invalids, 1)
12000 }
12001 return res
12002 })
12003 case "humanId":
12004 field := field
12005 out.Concurrently(i, func() (res graphql.Marshaler) {
12006 defer func() {
12007 if r := recover(); r != nil {
12008 ec.Error(ctx, ec.Recover(ctx, r))
12009 }
12010 }()
12011 res = ec._Identity_humanId(ctx, field, obj)
12012 if res == graphql.Null {
12013 atomic.AddUint32(&invalids, 1)
12014 }
12015 return res
12016 })
12017 case "name":
12018 out.Values[i] = ec._Identity_name(ctx, field, obj)
12019 case "email":
12020 out.Values[i] = ec._Identity_email(ctx, field, obj)
12021 case "displayName":
12022 out.Values[i] = ec._Identity_displayName(ctx, field, obj)
12023 if out.Values[i] == graphql.Null {
12024 atomic.AddUint32(&invalids, 1)
12025 }
12026 case "avatarUrl":
12027 out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
12028 case "isProtected":
12029 out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
12030 if out.Values[i] == graphql.Null {
12031 atomic.AddUint32(&invalids, 1)
12032 }
12033 default:
12034 panic("unknown field " + strconv.Quote(field.Name))
12035 }
12036 }
12037 out.Dispatch()
12038 if invalids > 0 {
12039 return graphql.Null
12040 }
12041 return out
12042}
12043
12044var identityConnectionImplementors = []string{"IdentityConnection"}
12045
12046func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
12047 fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
12048
12049 out := graphql.NewFieldSet(fields)
12050 var invalids uint32
12051 for i, field := range fields {
12052 switch field.Name {
12053 case "__typename":
12054 out.Values[i] = graphql.MarshalString("IdentityConnection")
12055 case "edges":
12056 out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
12057 if out.Values[i] == graphql.Null {
12058 invalids++
12059 }
12060 case "nodes":
12061 out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
12062 if out.Values[i] == graphql.Null {
12063 invalids++
12064 }
12065 case "pageInfo":
12066 out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
12067 if out.Values[i] == graphql.Null {
12068 invalids++
12069 }
12070 case "totalCount":
12071 out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
12072 if out.Values[i] == graphql.Null {
12073 invalids++
12074 }
12075 default:
12076 panic("unknown field " + strconv.Quote(field.Name))
12077 }
12078 }
12079 out.Dispatch()
12080 if invalids > 0 {
12081 return graphql.Null
12082 }
12083 return out
12084}
12085
12086var identityEdgeImplementors = []string{"IdentityEdge"}
12087
12088func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
12089 fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
12090
12091 out := graphql.NewFieldSet(fields)
12092 var invalids uint32
12093 for i, field := range fields {
12094 switch field.Name {
12095 case "__typename":
12096 out.Values[i] = graphql.MarshalString("IdentityEdge")
12097 case "cursor":
12098 out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
12099 if out.Values[i] == graphql.Null {
12100 invalids++
12101 }
12102 case "node":
12103 out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
12104 if out.Values[i] == graphql.Null {
12105 invalids++
12106 }
12107 default:
12108 panic("unknown field " + strconv.Quote(field.Name))
12109 }
12110 }
12111 out.Dispatch()
12112 if invalids > 0 {
12113 return graphql.Null
12114 }
12115 return out
12116}
12117
12118var labelImplementors = []string{"Label"}
12119
12120func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
12121 fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
12122
12123 out := graphql.NewFieldSet(fields)
12124 var invalids uint32
12125 for i, field := range fields {
12126 switch field.Name {
12127 case "__typename":
12128 out.Values[i] = graphql.MarshalString("Label")
12129 case "name":
12130 field := field
12131 out.Concurrently(i, func() (res graphql.Marshaler) {
12132 defer func() {
12133 if r := recover(); r != nil {
12134 ec.Error(ctx, ec.Recover(ctx, r))
12135 }
12136 }()
12137 res = ec._Label_name(ctx, field, obj)
12138 if res == graphql.Null {
12139 atomic.AddUint32(&invalids, 1)
12140 }
12141 return res
12142 })
12143 case "color":
12144 field := field
12145 out.Concurrently(i, func() (res graphql.Marshaler) {
12146 defer func() {
12147 if r := recover(); r != nil {
12148 ec.Error(ctx, ec.Recover(ctx, r))
12149 }
12150 }()
12151 res = ec._Label_color(ctx, field, obj)
12152 if res == graphql.Null {
12153 atomic.AddUint32(&invalids, 1)
12154 }
12155 return res
12156 })
12157 default:
12158 panic("unknown field " + strconv.Quote(field.Name))
12159 }
12160 }
12161 out.Dispatch()
12162 if invalids > 0 {
12163 return graphql.Null
12164 }
12165 return out
12166}
12167
12168var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
12169
12170func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
12171 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
12172
12173 out := graphql.NewFieldSet(fields)
12174 var invalids uint32
12175 for i, field := range fields {
12176 switch field.Name {
12177 case "__typename":
12178 out.Values[i] = graphql.MarshalString("LabelChangeOperation")
12179 case "id":
12180 field := field
12181 out.Concurrently(i, func() (res graphql.Marshaler) {
12182 defer func() {
12183 if r := recover(); r != nil {
12184 ec.Error(ctx, ec.Recover(ctx, r))
12185 }
12186 }()
12187 res = ec._LabelChangeOperation_id(ctx, field, obj)
12188 if res == graphql.Null {
12189 atomic.AddUint32(&invalids, 1)
12190 }
12191 return res
12192 })
12193 case "author":
12194 field := field
12195 out.Concurrently(i, func() (res graphql.Marshaler) {
12196 defer func() {
12197 if r := recover(); r != nil {
12198 ec.Error(ctx, ec.Recover(ctx, r))
12199 }
12200 }()
12201 res = ec._LabelChangeOperation_author(ctx, field, obj)
12202 if res == graphql.Null {
12203 atomic.AddUint32(&invalids, 1)
12204 }
12205 return res
12206 })
12207 case "date":
12208 field := field
12209 out.Concurrently(i, func() (res graphql.Marshaler) {
12210 defer func() {
12211 if r := recover(); r != nil {
12212 ec.Error(ctx, ec.Recover(ctx, r))
12213 }
12214 }()
12215 res = ec._LabelChangeOperation_date(ctx, field, obj)
12216 if res == graphql.Null {
12217 atomic.AddUint32(&invalids, 1)
12218 }
12219 return res
12220 })
12221 case "added":
12222 out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
12223 if out.Values[i] == graphql.Null {
12224 atomic.AddUint32(&invalids, 1)
12225 }
12226 case "removed":
12227 out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
12228 if out.Values[i] == graphql.Null {
12229 atomic.AddUint32(&invalids, 1)
12230 }
12231 default:
12232 panic("unknown field " + strconv.Quote(field.Name))
12233 }
12234 }
12235 out.Dispatch()
12236 if invalids > 0 {
12237 return graphql.Null
12238 }
12239 return out
12240}
12241
12242var labelChangeResultImplementors = []string{"LabelChangeResult"}
12243
12244func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
12245 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
12246
12247 out := graphql.NewFieldSet(fields)
12248 var invalids uint32
12249 for i, field := range fields {
12250 switch field.Name {
12251 case "__typename":
12252 out.Values[i] = graphql.MarshalString("LabelChangeResult")
12253 case "label":
12254 out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
12255 if out.Values[i] == graphql.Null {
12256 atomic.AddUint32(&invalids, 1)
12257 }
12258 case "status":
12259 field := field
12260 out.Concurrently(i, func() (res graphql.Marshaler) {
12261 defer func() {
12262 if r := recover(); r != nil {
12263 ec.Error(ctx, ec.Recover(ctx, r))
12264 }
12265 }()
12266 res = ec._LabelChangeResult_status(ctx, field, obj)
12267 if res == graphql.Null {
12268 atomic.AddUint32(&invalids, 1)
12269 }
12270 return res
12271 })
12272 default:
12273 panic("unknown field " + strconv.Quote(field.Name))
12274 }
12275 }
12276 out.Dispatch()
12277 if invalids > 0 {
12278 return graphql.Null
12279 }
12280 return out
12281}
12282
12283var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
12284
12285func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
12286 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
12287
12288 out := graphql.NewFieldSet(fields)
12289 var invalids uint32
12290 for i, field := range fields {
12291 switch field.Name {
12292 case "__typename":
12293 out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
12294 case "id":
12295 field := field
12296 out.Concurrently(i, func() (res graphql.Marshaler) {
12297 defer func() {
12298 if r := recover(); r != nil {
12299 ec.Error(ctx, ec.Recover(ctx, r))
12300 }
12301 }()
12302 res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
12303 if res == graphql.Null {
12304 atomic.AddUint32(&invalids, 1)
12305 }
12306 return res
12307 })
12308 case "author":
12309 field := field
12310 out.Concurrently(i, func() (res graphql.Marshaler) {
12311 defer func() {
12312 if r := recover(); r != nil {
12313 ec.Error(ctx, ec.Recover(ctx, r))
12314 }
12315 }()
12316 res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
12317 if res == graphql.Null {
12318 atomic.AddUint32(&invalids, 1)
12319 }
12320 return res
12321 })
12322 case "date":
12323 field := field
12324 out.Concurrently(i, func() (res graphql.Marshaler) {
12325 defer func() {
12326 if r := recover(); r != nil {
12327 ec.Error(ctx, ec.Recover(ctx, r))
12328 }
12329 }()
12330 res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
12331 if res == graphql.Null {
12332 atomic.AddUint32(&invalids, 1)
12333 }
12334 return res
12335 })
12336 case "added":
12337 out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
12338 if out.Values[i] == graphql.Null {
12339 atomic.AddUint32(&invalids, 1)
12340 }
12341 case "removed":
12342 out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
12343 if out.Values[i] == graphql.Null {
12344 atomic.AddUint32(&invalids, 1)
12345 }
12346 default:
12347 panic("unknown field " + strconv.Quote(field.Name))
12348 }
12349 }
12350 out.Dispatch()
12351 if invalids > 0 {
12352 return graphql.Null
12353 }
12354 return out
12355}
12356
12357var labelConnectionImplementors = []string{"LabelConnection"}
12358
12359func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
12360 fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
12361
12362 out := graphql.NewFieldSet(fields)
12363 var invalids uint32
12364 for i, field := range fields {
12365 switch field.Name {
12366 case "__typename":
12367 out.Values[i] = graphql.MarshalString("LabelConnection")
12368 case "edges":
12369 out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
12370 if out.Values[i] == graphql.Null {
12371 invalids++
12372 }
12373 case "nodes":
12374 out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
12375 if out.Values[i] == graphql.Null {
12376 invalids++
12377 }
12378 case "pageInfo":
12379 out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
12380 if out.Values[i] == graphql.Null {
12381 invalids++
12382 }
12383 case "totalCount":
12384 out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
12385 if out.Values[i] == graphql.Null {
12386 invalids++
12387 }
12388 default:
12389 panic("unknown field " + strconv.Quote(field.Name))
12390 }
12391 }
12392 out.Dispatch()
12393 if invalids > 0 {
12394 return graphql.Null
12395 }
12396 return out
12397}
12398
12399var labelEdgeImplementors = []string{"LabelEdge"}
12400
12401func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
12402 fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
12403
12404 out := graphql.NewFieldSet(fields)
12405 var invalids uint32
12406 for i, field := range fields {
12407 switch field.Name {
12408 case "__typename":
12409 out.Values[i] = graphql.MarshalString("LabelEdge")
12410 case "cursor":
12411 out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
12412 if out.Values[i] == graphql.Null {
12413 invalids++
12414 }
12415 case "node":
12416 out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
12417 if out.Values[i] == graphql.Null {
12418 invalids++
12419 }
12420 default:
12421 panic("unknown field " + strconv.Quote(field.Name))
12422 }
12423 }
12424 out.Dispatch()
12425 if invalids > 0 {
12426 return graphql.Null
12427 }
12428 return out
12429}
12430
12431var mutationImplementors = []string{"Mutation"}
12432
12433func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12434 fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
12435
12436 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12437 Object: "Mutation",
12438 })
12439
12440 out := graphql.NewFieldSet(fields)
12441 var invalids uint32
12442 for i, field := range fields {
12443 switch field.Name {
12444 case "__typename":
12445 out.Values[i] = graphql.MarshalString("Mutation")
12446 case "newBug":
12447 out.Values[i] = ec._Mutation_newBug(ctx, field)
12448 if out.Values[i] == graphql.Null {
12449 invalids++
12450 }
12451 case "addComment":
12452 out.Values[i] = ec._Mutation_addComment(ctx, field)
12453 if out.Values[i] == graphql.Null {
12454 invalids++
12455 }
12456 case "changeLabels":
12457 out.Values[i] = ec._Mutation_changeLabels(ctx, field)
12458 if out.Values[i] == graphql.Null {
12459 invalids++
12460 }
12461 case "openBug":
12462 out.Values[i] = ec._Mutation_openBug(ctx, field)
12463 if out.Values[i] == graphql.Null {
12464 invalids++
12465 }
12466 case "closeBug":
12467 out.Values[i] = ec._Mutation_closeBug(ctx, field)
12468 if out.Values[i] == graphql.Null {
12469 invalids++
12470 }
12471 case "setTitle":
12472 out.Values[i] = ec._Mutation_setTitle(ctx, field)
12473 if out.Values[i] == graphql.Null {
12474 invalids++
12475 }
12476 case "startTransaction":
12477 out.Values[i] = ec._Mutation_startTransaction(ctx, field)
12478 if out.Values[i] == graphql.Null {
12479 invalids++
12480 }
12481 case "commit":
12482 out.Values[i] = ec._Mutation_commit(ctx, field)
12483 if out.Values[i] == graphql.Null {
12484 invalids++
12485 }
12486 case "rollback":
12487 out.Values[i] = ec._Mutation_rollback(ctx, field)
12488 if out.Values[i] == graphql.Null {
12489 invalids++
12490 }
12491 default:
12492 panic("unknown field " + strconv.Quote(field.Name))
12493 }
12494 }
12495 out.Dispatch()
12496 if invalids > 0 {
12497 return graphql.Null
12498 }
12499 return out
12500}
12501
12502var newBugPayloadImplementors = []string{"NewBugPayload"}
12503
12504func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
12505 fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
12506
12507 out := graphql.NewFieldSet(fields)
12508 var invalids uint32
12509 for i, field := range fields {
12510 switch field.Name {
12511 case "__typename":
12512 out.Values[i] = graphql.MarshalString("NewBugPayload")
12513 case "clientMutationId":
12514 out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
12515 case "bug":
12516 out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
12517 if out.Values[i] == graphql.Null {
12518 invalids++
12519 }
12520 case "operation":
12521 out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
12522 if out.Values[i] == graphql.Null {
12523 invalids++
12524 }
12525 default:
12526 panic("unknown field " + strconv.Quote(field.Name))
12527 }
12528 }
12529 out.Dispatch()
12530 if invalids > 0 {
12531 return graphql.Null
12532 }
12533 return out
12534}
12535
12536var openBugPayloadImplementors = []string{"OpenBugPayload"}
12537
12538func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
12539 fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
12540
12541 out := graphql.NewFieldSet(fields)
12542 var invalids uint32
12543 for i, field := range fields {
12544 switch field.Name {
12545 case "__typename":
12546 out.Values[i] = graphql.MarshalString("OpenBugPayload")
12547 case "clientMutationId":
12548 out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
12549 case "bug":
12550 out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
12551 if out.Values[i] == graphql.Null {
12552 invalids++
12553 }
12554 case "operation":
12555 out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
12556 if out.Values[i] == graphql.Null {
12557 invalids++
12558 }
12559 default:
12560 panic("unknown field " + strconv.Quote(field.Name))
12561 }
12562 }
12563 out.Dispatch()
12564 if invalids > 0 {
12565 return graphql.Null
12566 }
12567 return out
12568}
12569
12570var operationConnectionImplementors = []string{"OperationConnection"}
12571
12572func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
12573 fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
12574
12575 out := graphql.NewFieldSet(fields)
12576 var invalids uint32
12577 for i, field := range fields {
12578 switch field.Name {
12579 case "__typename":
12580 out.Values[i] = graphql.MarshalString("OperationConnection")
12581 case "edges":
12582 out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
12583 if out.Values[i] == graphql.Null {
12584 invalids++
12585 }
12586 case "nodes":
12587 out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
12588 if out.Values[i] == graphql.Null {
12589 invalids++
12590 }
12591 case "pageInfo":
12592 out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
12593 if out.Values[i] == graphql.Null {
12594 invalids++
12595 }
12596 case "totalCount":
12597 out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
12598 if out.Values[i] == graphql.Null {
12599 invalids++
12600 }
12601 default:
12602 panic("unknown field " + strconv.Quote(field.Name))
12603 }
12604 }
12605 out.Dispatch()
12606 if invalids > 0 {
12607 return graphql.Null
12608 }
12609 return out
12610}
12611
12612var operationEdgeImplementors = []string{"OperationEdge"}
12613
12614func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
12615 fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
12616
12617 out := graphql.NewFieldSet(fields)
12618 var invalids uint32
12619 for i, field := range fields {
12620 switch field.Name {
12621 case "__typename":
12622 out.Values[i] = graphql.MarshalString("OperationEdge")
12623 case "cursor":
12624 out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
12625 if out.Values[i] == graphql.Null {
12626 invalids++
12627 }
12628 case "node":
12629 out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
12630 if out.Values[i] == graphql.Null {
12631 invalids++
12632 }
12633 default:
12634 panic("unknown field " + strconv.Quote(field.Name))
12635 }
12636 }
12637 out.Dispatch()
12638 if invalids > 0 {
12639 return graphql.Null
12640 }
12641 return out
12642}
12643
12644var pageInfoImplementors = []string{"PageInfo"}
12645
12646func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
12647 fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
12648
12649 out := graphql.NewFieldSet(fields)
12650 var invalids uint32
12651 for i, field := range fields {
12652 switch field.Name {
12653 case "__typename":
12654 out.Values[i] = graphql.MarshalString("PageInfo")
12655 case "hasNextPage":
12656 out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
12657 if out.Values[i] == graphql.Null {
12658 invalids++
12659 }
12660 case "hasPreviousPage":
12661 out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
12662 if out.Values[i] == graphql.Null {
12663 invalids++
12664 }
12665 case "startCursor":
12666 out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
12667 if out.Values[i] == graphql.Null {
12668 invalids++
12669 }
12670 case "endCursor":
12671 out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
12672 if out.Values[i] == graphql.Null {
12673 invalids++
12674 }
12675 default:
12676 panic("unknown field " + strconv.Quote(field.Name))
12677 }
12678 }
12679 out.Dispatch()
12680 if invalids > 0 {
12681 return graphql.Null
12682 }
12683 return out
12684}
12685
12686var queryImplementors = []string{"Query"}
12687
12688func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12689 fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
12690
12691 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12692 Object: "Query",
12693 })
12694
12695 out := graphql.NewFieldSet(fields)
12696 var invalids uint32
12697 for i, field := range fields {
12698 switch field.Name {
12699 case "__typename":
12700 out.Values[i] = graphql.MarshalString("Query")
12701 case "repository":
12702 field := field
12703 out.Concurrently(i, func() (res graphql.Marshaler) {
12704 defer func() {
12705 if r := recover(); r != nil {
12706 ec.Error(ctx, ec.Recover(ctx, r))
12707 }
12708 }()
12709 res = ec._Query_repository(ctx, field)
12710 return res
12711 })
12712 case "__type":
12713 out.Values[i] = ec._Query___type(ctx, field)
12714 case "__schema":
12715 out.Values[i] = ec._Query___schema(ctx, field)
12716 default:
12717 panic("unknown field " + strconv.Quote(field.Name))
12718 }
12719 }
12720 out.Dispatch()
12721 if invalids > 0 {
12722 return graphql.Null
12723 }
12724 return out
12725}
12726
12727var repositoryImplementors = []string{"Repository"}
12728
12729func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
12730 fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
12731
12732 out := graphql.NewFieldSet(fields)
12733 var invalids uint32
12734 for i, field := range fields {
12735 switch field.Name {
12736 case "__typename":
12737 out.Values[i] = graphql.MarshalString("Repository")
12738 case "name":
12739 field := field
12740 out.Concurrently(i, func() (res graphql.Marshaler) {
12741 defer func() {
12742 if r := recover(); r != nil {
12743 ec.Error(ctx, ec.Recover(ctx, r))
12744 }
12745 }()
12746 res = ec._Repository_name(ctx, field, obj)
12747 return res
12748 })
12749 case "allBugs":
12750 field := field
12751 out.Concurrently(i, func() (res graphql.Marshaler) {
12752 defer func() {
12753 if r := recover(); r != nil {
12754 ec.Error(ctx, ec.Recover(ctx, r))
12755 }
12756 }()
12757 res = ec._Repository_allBugs(ctx, field, obj)
12758 if res == graphql.Null {
12759 atomic.AddUint32(&invalids, 1)
12760 }
12761 return res
12762 })
12763 case "bug":
12764 field := field
12765 out.Concurrently(i, func() (res graphql.Marshaler) {
12766 defer func() {
12767 if r := recover(); r != nil {
12768 ec.Error(ctx, ec.Recover(ctx, r))
12769 }
12770 }()
12771 res = ec._Repository_bug(ctx, field, obj)
12772 return res
12773 })
12774 case "allIdentities":
12775 field := field
12776 out.Concurrently(i, func() (res graphql.Marshaler) {
12777 defer func() {
12778 if r := recover(); r != nil {
12779 ec.Error(ctx, ec.Recover(ctx, r))
12780 }
12781 }()
12782 res = ec._Repository_allIdentities(ctx, field, obj)
12783 if res == graphql.Null {
12784 atomic.AddUint32(&invalids, 1)
12785 }
12786 return res
12787 })
12788 case "identity":
12789 field := field
12790 out.Concurrently(i, func() (res graphql.Marshaler) {
12791 defer func() {
12792 if r := recover(); r != nil {
12793 ec.Error(ctx, ec.Recover(ctx, r))
12794 }
12795 }()
12796 res = ec._Repository_identity(ctx, field, obj)
12797 return res
12798 })
12799 case "userIdentity":
12800 field := field
12801 out.Concurrently(i, func() (res graphql.Marshaler) {
12802 defer func() {
12803 if r := recover(); r != nil {
12804 ec.Error(ctx, ec.Recover(ctx, r))
12805 }
12806 }()
12807 res = ec._Repository_userIdentity(ctx, field, obj)
12808 return res
12809 })
12810 case "validLabels":
12811 field := field
12812 out.Concurrently(i, func() (res graphql.Marshaler) {
12813 defer func() {
12814 if r := recover(); r != nil {
12815 ec.Error(ctx, ec.Recover(ctx, r))
12816 }
12817 }()
12818 res = ec._Repository_validLabels(ctx, field, obj)
12819 if res == graphql.Null {
12820 atomic.AddUint32(&invalids, 1)
12821 }
12822 return res
12823 })
12824 default:
12825 panic("unknown field " + strconv.Quote(field.Name))
12826 }
12827 }
12828 out.Dispatch()
12829 if invalids > 0 {
12830 return graphql.Null
12831 }
12832 return out
12833}
12834
12835var rollbackPayloadImplementors = []string{"RollbackPayload"}
12836
12837func (ec *executionContext) _RollbackPayload(ctx context.Context, sel ast.SelectionSet, obj *models.RollbackPayload) graphql.Marshaler {
12838 fields := graphql.CollectFields(ec.OperationContext, sel, rollbackPayloadImplementors)
12839
12840 out := graphql.NewFieldSet(fields)
12841 var invalids uint32
12842 for i, field := range fields {
12843 switch field.Name {
12844 case "__typename":
12845 out.Values[i] = graphql.MarshalString("RollbackPayload")
12846 case "clientMutationId":
12847 out.Values[i] = ec._RollbackPayload_clientMutationId(ctx, field, obj)
12848 case "id":
12849 out.Values[i] = ec._RollbackPayload_id(ctx, field, obj)
12850 if out.Values[i] == graphql.Null {
12851 invalids++
12852 }
12853 case "bug":
12854 out.Values[i] = ec._RollbackPayload_bug(ctx, field, obj)
12855 if out.Values[i] == graphql.Null {
12856 invalids++
12857 }
12858 default:
12859 panic("unknown field " + strconv.Quote(field.Name))
12860 }
12861 }
12862 out.Dispatch()
12863 if invalids > 0 {
12864 return graphql.Null
12865 }
12866 return out
12867}
12868
12869var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
12870
12871func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
12872 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
12873
12874 out := graphql.NewFieldSet(fields)
12875 var invalids uint32
12876 for i, field := range fields {
12877 switch field.Name {
12878 case "__typename":
12879 out.Values[i] = graphql.MarshalString("SetStatusOperation")
12880 case "id":
12881 field := field
12882 out.Concurrently(i, func() (res graphql.Marshaler) {
12883 defer func() {
12884 if r := recover(); r != nil {
12885 ec.Error(ctx, ec.Recover(ctx, r))
12886 }
12887 }()
12888 res = ec._SetStatusOperation_id(ctx, field, obj)
12889 if res == graphql.Null {
12890 atomic.AddUint32(&invalids, 1)
12891 }
12892 return res
12893 })
12894 case "author":
12895 field := field
12896 out.Concurrently(i, func() (res graphql.Marshaler) {
12897 defer func() {
12898 if r := recover(); r != nil {
12899 ec.Error(ctx, ec.Recover(ctx, r))
12900 }
12901 }()
12902 res = ec._SetStatusOperation_author(ctx, field, obj)
12903 if res == graphql.Null {
12904 atomic.AddUint32(&invalids, 1)
12905 }
12906 return res
12907 })
12908 case "date":
12909 field := field
12910 out.Concurrently(i, func() (res graphql.Marshaler) {
12911 defer func() {
12912 if r := recover(); r != nil {
12913 ec.Error(ctx, ec.Recover(ctx, r))
12914 }
12915 }()
12916 res = ec._SetStatusOperation_date(ctx, field, obj)
12917 if res == graphql.Null {
12918 atomic.AddUint32(&invalids, 1)
12919 }
12920 return res
12921 })
12922 case "status":
12923 field := field
12924 out.Concurrently(i, func() (res graphql.Marshaler) {
12925 defer func() {
12926 if r := recover(); r != nil {
12927 ec.Error(ctx, ec.Recover(ctx, r))
12928 }
12929 }()
12930 res = ec._SetStatusOperation_status(ctx, field, obj)
12931 if res == graphql.Null {
12932 atomic.AddUint32(&invalids, 1)
12933 }
12934 return res
12935 })
12936 default:
12937 panic("unknown field " + strconv.Quote(field.Name))
12938 }
12939 }
12940 out.Dispatch()
12941 if invalids > 0 {
12942 return graphql.Null
12943 }
12944 return out
12945}
12946
12947var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
12948
12949func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
12950 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
12951
12952 out := graphql.NewFieldSet(fields)
12953 var invalids uint32
12954 for i, field := range fields {
12955 switch field.Name {
12956 case "__typename":
12957 out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
12958 case "id":
12959 field := field
12960 out.Concurrently(i, func() (res graphql.Marshaler) {
12961 defer func() {
12962 if r := recover(); r != nil {
12963 ec.Error(ctx, ec.Recover(ctx, r))
12964 }
12965 }()
12966 res = ec._SetStatusTimelineItem_id(ctx, field, obj)
12967 if res == graphql.Null {
12968 atomic.AddUint32(&invalids, 1)
12969 }
12970 return res
12971 })
12972 case "author":
12973 field := field
12974 out.Concurrently(i, func() (res graphql.Marshaler) {
12975 defer func() {
12976 if r := recover(); r != nil {
12977 ec.Error(ctx, ec.Recover(ctx, r))
12978 }
12979 }()
12980 res = ec._SetStatusTimelineItem_author(ctx, field, obj)
12981 if res == graphql.Null {
12982 atomic.AddUint32(&invalids, 1)
12983 }
12984 return res
12985 })
12986 case "date":
12987 field := field
12988 out.Concurrently(i, func() (res graphql.Marshaler) {
12989 defer func() {
12990 if r := recover(); r != nil {
12991 ec.Error(ctx, ec.Recover(ctx, r))
12992 }
12993 }()
12994 res = ec._SetStatusTimelineItem_date(ctx, field, obj)
12995 if res == graphql.Null {
12996 atomic.AddUint32(&invalids, 1)
12997 }
12998 return res
12999 })
13000 case "status":
13001 field := field
13002 out.Concurrently(i, func() (res graphql.Marshaler) {
13003 defer func() {
13004 if r := recover(); r != nil {
13005 ec.Error(ctx, ec.Recover(ctx, r))
13006 }
13007 }()
13008 res = ec._SetStatusTimelineItem_status(ctx, field, obj)
13009 if res == graphql.Null {
13010 atomic.AddUint32(&invalids, 1)
13011 }
13012 return res
13013 })
13014 default:
13015 panic("unknown field " + strconv.Quote(field.Name))
13016 }
13017 }
13018 out.Dispatch()
13019 if invalids > 0 {
13020 return graphql.Null
13021 }
13022 return out
13023}
13024
13025var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
13026
13027func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
13028 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
13029
13030 out := graphql.NewFieldSet(fields)
13031 var invalids uint32
13032 for i, field := range fields {
13033 switch field.Name {
13034 case "__typename":
13035 out.Values[i] = graphql.MarshalString("SetTitleOperation")
13036 case "id":
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._SetTitleOperation_id(ctx, field, obj)
13045 if res == graphql.Null {
13046 atomic.AddUint32(&invalids, 1)
13047 }
13048 return res
13049 })
13050 case "author":
13051 field := field
13052 out.Concurrently(i, func() (res graphql.Marshaler) {
13053 defer func() {
13054 if r := recover(); r != nil {
13055 ec.Error(ctx, ec.Recover(ctx, r))
13056 }
13057 }()
13058 res = ec._SetTitleOperation_author(ctx, field, obj)
13059 if res == graphql.Null {
13060 atomic.AddUint32(&invalids, 1)
13061 }
13062 return res
13063 })
13064 case "date":
13065 field := field
13066 out.Concurrently(i, func() (res graphql.Marshaler) {
13067 defer func() {
13068 if r := recover(); r != nil {
13069 ec.Error(ctx, ec.Recover(ctx, r))
13070 }
13071 }()
13072 res = ec._SetTitleOperation_date(ctx, field, obj)
13073 if res == graphql.Null {
13074 atomic.AddUint32(&invalids, 1)
13075 }
13076 return res
13077 })
13078 case "title":
13079 out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
13080 if out.Values[i] == graphql.Null {
13081 atomic.AddUint32(&invalids, 1)
13082 }
13083 case "was":
13084 out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
13085 if out.Values[i] == graphql.Null {
13086 atomic.AddUint32(&invalids, 1)
13087 }
13088 default:
13089 panic("unknown field " + strconv.Quote(field.Name))
13090 }
13091 }
13092 out.Dispatch()
13093 if invalids > 0 {
13094 return graphql.Null
13095 }
13096 return out
13097}
13098
13099var setTitlePayloadImplementors = []string{"SetTitlePayload"}
13100
13101func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
13102 fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
13103
13104 out := graphql.NewFieldSet(fields)
13105 var invalids uint32
13106 for i, field := range fields {
13107 switch field.Name {
13108 case "__typename":
13109 out.Values[i] = graphql.MarshalString("SetTitlePayload")
13110 case "clientMutationId":
13111 out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
13112 case "bug":
13113 out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
13114 if out.Values[i] == graphql.Null {
13115 invalids++
13116 }
13117 case "operation":
13118 out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
13119 if out.Values[i] == graphql.Null {
13120 invalids++
13121 }
13122 default:
13123 panic("unknown field " + strconv.Quote(field.Name))
13124 }
13125 }
13126 out.Dispatch()
13127 if invalids > 0 {
13128 return graphql.Null
13129 }
13130 return out
13131}
13132
13133var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
13134
13135func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
13136 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
13137
13138 out := graphql.NewFieldSet(fields)
13139 var invalids uint32
13140 for i, field := range fields {
13141 switch field.Name {
13142 case "__typename":
13143 out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
13144 case "id":
13145 field := field
13146 out.Concurrently(i, func() (res graphql.Marshaler) {
13147 defer func() {
13148 if r := recover(); r != nil {
13149 ec.Error(ctx, ec.Recover(ctx, r))
13150 }
13151 }()
13152 res = ec._SetTitleTimelineItem_id(ctx, field, obj)
13153 if res == graphql.Null {
13154 atomic.AddUint32(&invalids, 1)
13155 }
13156 return res
13157 })
13158 case "author":
13159 field := field
13160 out.Concurrently(i, func() (res graphql.Marshaler) {
13161 defer func() {
13162 if r := recover(); r != nil {
13163 ec.Error(ctx, ec.Recover(ctx, r))
13164 }
13165 }()
13166 res = ec._SetTitleTimelineItem_author(ctx, field, obj)
13167 if res == graphql.Null {
13168 atomic.AddUint32(&invalids, 1)
13169 }
13170 return res
13171 })
13172 case "date":
13173 field := field
13174 out.Concurrently(i, func() (res graphql.Marshaler) {
13175 defer func() {
13176 if r := recover(); r != nil {
13177 ec.Error(ctx, ec.Recover(ctx, r))
13178 }
13179 }()
13180 res = ec._SetTitleTimelineItem_date(ctx, field, obj)
13181 if res == graphql.Null {
13182 atomic.AddUint32(&invalids, 1)
13183 }
13184 return res
13185 })
13186 case "title":
13187 out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
13188 if out.Values[i] == graphql.Null {
13189 atomic.AddUint32(&invalids, 1)
13190 }
13191 case "was":
13192 out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
13193 if out.Values[i] == graphql.Null {
13194 atomic.AddUint32(&invalids, 1)
13195 }
13196 default:
13197 panic("unknown field " + strconv.Quote(field.Name))
13198 }
13199 }
13200 out.Dispatch()
13201 if invalids > 0 {
13202 return graphql.Null
13203 }
13204 return out
13205}
13206
13207var startTransactionPayloadImplementors = []string{"StartTransactionPayload"}
13208
13209func (ec *executionContext) _StartTransactionPayload(ctx context.Context, sel ast.SelectionSet, obj *models.StartTransactionPayload) graphql.Marshaler {
13210 fields := graphql.CollectFields(ec.OperationContext, sel, startTransactionPayloadImplementors)
13211
13212 out := graphql.NewFieldSet(fields)
13213 var invalids uint32
13214 for i, field := range fields {
13215 switch field.Name {
13216 case "__typename":
13217 out.Values[i] = graphql.MarshalString("StartTransactionPayload")
13218 case "clientMutationId":
13219 out.Values[i] = ec._StartTransactionPayload_clientMutationId(ctx, field, obj)
13220 case "id":
13221 out.Values[i] = ec._StartTransactionPayload_id(ctx, field, obj)
13222 if out.Values[i] == graphql.Null {
13223 invalids++
13224 }
13225 default:
13226 panic("unknown field " + strconv.Quote(field.Name))
13227 }
13228 }
13229 out.Dispatch()
13230 if invalids > 0 {
13231 return graphql.Null
13232 }
13233 return out
13234}
13235
13236var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
13237
13238func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
13239 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
13240
13241 out := graphql.NewFieldSet(fields)
13242 var invalids uint32
13243 for i, field := range fields {
13244 switch field.Name {
13245 case "__typename":
13246 out.Values[i] = graphql.MarshalString("TimelineItemConnection")
13247 case "edges":
13248 out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
13249 if out.Values[i] == graphql.Null {
13250 invalids++
13251 }
13252 case "nodes":
13253 out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
13254 if out.Values[i] == graphql.Null {
13255 invalids++
13256 }
13257 case "pageInfo":
13258 out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
13259 if out.Values[i] == graphql.Null {
13260 invalids++
13261 }
13262 case "totalCount":
13263 out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
13264 if out.Values[i] == graphql.Null {
13265 invalids++
13266 }
13267 default:
13268 panic("unknown field " + strconv.Quote(field.Name))
13269 }
13270 }
13271 out.Dispatch()
13272 if invalids > 0 {
13273 return graphql.Null
13274 }
13275 return out
13276}
13277
13278var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
13279
13280func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
13281 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
13282
13283 out := graphql.NewFieldSet(fields)
13284 var invalids uint32
13285 for i, field := range fields {
13286 switch field.Name {
13287 case "__typename":
13288 out.Values[i] = graphql.MarshalString("TimelineItemEdge")
13289 case "cursor":
13290 out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
13291 if out.Values[i] == graphql.Null {
13292 invalids++
13293 }
13294 case "node":
13295 out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
13296 if out.Values[i] == graphql.Null {
13297 invalids++
13298 }
13299 default:
13300 panic("unknown field " + strconv.Quote(field.Name))
13301 }
13302 }
13303 out.Dispatch()
13304 if invalids > 0 {
13305 return graphql.Null
13306 }
13307 return out
13308}
13309
13310var __DirectiveImplementors = []string{"__Directive"}
13311
13312func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
13313 fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
13314
13315 out := graphql.NewFieldSet(fields)
13316 var invalids uint32
13317 for i, field := range fields {
13318 switch field.Name {
13319 case "__typename":
13320 out.Values[i] = graphql.MarshalString("__Directive")
13321 case "name":
13322 out.Values[i] = ec.___Directive_name(ctx, field, obj)
13323 if out.Values[i] == graphql.Null {
13324 invalids++
13325 }
13326 case "description":
13327 out.Values[i] = ec.___Directive_description(ctx, field, obj)
13328 case "locations":
13329 out.Values[i] = ec.___Directive_locations(ctx, field, obj)
13330 if out.Values[i] == graphql.Null {
13331 invalids++
13332 }
13333 case "args":
13334 out.Values[i] = ec.___Directive_args(ctx, field, obj)
13335 if out.Values[i] == graphql.Null {
13336 invalids++
13337 }
13338 default:
13339 panic("unknown field " + strconv.Quote(field.Name))
13340 }
13341 }
13342 out.Dispatch()
13343 if invalids > 0 {
13344 return graphql.Null
13345 }
13346 return out
13347}
13348
13349var __EnumValueImplementors = []string{"__EnumValue"}
13350
13351func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
13352 fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
13353
13354 out := graphql.NewFieldSet(fields)
13355 var invalids uint32
13356 for i, field := range fields {
13357 switch field.Name {
13358 case "__typename":
13359 out.Values[i] = graphql.MarshalString("__EnumValue")
13360 case "name":
13361 out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
13362 if out.Values[i] == graphql.Null {
13363 invalids++
13364 }
13365 case "description":
13366 out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
13367 case "isDeprecated":
13368 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
13369 if out.Values[i] == graphql.Null {
13370 invalids++
13371 }
13372 case "deprecationReason":
13373 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
13374 default:
13375 panic("unknown field " + strconv.Quote(field.Name))
13376 }
13377 }
13378 out.Dispatch()
13379 if invalids > 0 {
13380 return graphql.Null
13381 }
13382 return out
13383}
13384
13385var __FieldImplementors = []string{"__Field"}
13386
13387func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
13388 fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
13389
13390 out := graphql.NewFieldSet(fields)
13391 var invalids uint32
13392 for i, field := range fields {
13393 switch field.Name {
13394 case "__typename":
13395 out.Values[i] = graphql.MarshalString("__Field")
13396 case "name":
13397 out.Values[i] = ec.___Field_name(ctx, field, obj)
13398 if out.Values[i] == graphql.Null {
13399 invalids++
13400 }
13401 case "description":
13402 out.Values[i] = ec.___Field_description(ctx, field, obj)
13403 case "args":
13404 out.Values[i] = ec.___Field_args(ctx, field, obj)
13405 if out.Values[i] == graphql.Null {
13406 invalids++
13407 }
13408 case "type":
13409 out.Values[i] = ec.___Field_type(ctx, field, obj)
13410 if out.Values[i] == graphql.Null {
13411 invalids++
13412 }
13413 case "isDeprecated":
13414 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
13415 if out.Values[i] == graphql.Null {
13416 invalids++
13417 }
13418 case "deprecationReason":
13419 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
13420 default:
13421 panic("unknown field " + strconv.Quote(field.Name))
13422 }
13423 }
13424 out.Dispatch()
13425 if invalids > 0 {
13426 return graphql.Null
13427 }
13428 return out
13429}
13430
13431var __InputValueImplementors = []string{"__InputValue"}
13432
13433func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
13434 fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
13435
13436 out := graphql.NewFieldSet(fields)
13437 var invalids uint32
13438 for i, field := range fields {
13439 switch field.Name {
13440 case "__typename":
13441 out.Values[i] = graphql.MarshalString("__InputValue")
13442 case "name":
13443 out.Values[i] = ec.___InputValue_name(ctx, field, obj)
13444 if out.Values[i] == graphql.Null {
13445 invalids++
13446 }
13447 case "description":
13448 out.Values[i] = ec.___InputValue_description(ctx, field, obj)
13449 case "type":
13450 out.Values[i] = ec.___InputValue_type(ctx, field, obj)
13451 if out.Values[i] == graphql.Null {
13452 invalids++
13453 }
13454 case "defaultValue":
13455 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
13456 default:
13457 panic("unknown field " + strconv.Quote(field.Name))
13458 }
13459 }
13460 out.Dispatch()
13461 if invalids > 0 {
13462 return graphql.Null
13463 }
13464 return out
13465}
13466
13467var __SchemaImplementors = []string{"__Schema"}
13468
13469func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
13470 fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
13471
13472 out := graphql.NewFieldSet(fields)
13473 var invalids uint32
13474 for i, field := range fields {
13475 switch field.Name {
13476 case "__typename":
13477 out.Values[i] = graphql.MarshalString("__Schema")
13478 case "types":
13479 out.Values[i] = ec.___Schema_types(ctx, field, obj)
13480 if out.Values[i] == graphql.Null {
13481 invalids++
13482 }
13483 case "queryType":
13484 out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
13485 if out.Values[i] == graphql.Null {
13486 invalids++
13487 }
13488 case "mutationType":
13489 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
13490 case "subscriptionType":
13491 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
13492 case "directives":
13493 out.Values[i] = ec.___Schema_directives(ctx, field, obj)
13494 if out.Values[i] == graphql.Null {
13495 invalids++
13496 }
13497 default:
13498 panic("unknown field " + strconv.Quote(field.Name))
13499 }
13500 }
13501 out.Dispatch()
13502 if invalids > 0 {
13503 return graphql.Null
13504 }
13505 return out
13506}
13507
13508var __TypeImplementors = []string{"__Type"}
13509
13510func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
13511 fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
13512
13513 out := graphql.NewFieldSet(fields)
13514 var invalids uint32
13515 for i, field := range fields {
13516 switch field.Name {
13517 case "__typename":
13518 out.Values[i] = graphql.MarshalString("__Type")
13519 case "kind":
13520 out.Values[i] = ec.___Type_kind(ctx, field, obj)
13521 if out.Values[i] == graphql.Null {
13522 invalids++
13523 }
13524 case "name":
13525 out.Values[i] = ec.___Type_name(ctx, field, obj)
13526 case "description":
13527 out.Values[i] = ec.___Type_description(ctx, field, obj)
13528 case "fields":
13529 out.Values[i] = ec.___Type_fields(ctx, field, obj)
13530 case "interfaces":
13531 out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
13532 case "possibleTypes":
13533 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
13534 case "enumValues":
13535 out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
13536 case "inputFields":
13537 out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
13538 case "ofType":
13539 out.Values[i] = ec.___Type_ofType(ctx, field, obj)
13540 default:
13541 panic("unknown field " + strconv.Quote(field.Name))
13542 }
13543 }
13544 out.Dispatch()
13545 if invalids > 0 {
13546 return graphql.Null
13547 }
13548 return out
13549}
13550
13551// endregion **************************** object.gotpl ****************************
13552
13553// region ***************************** type.gotpl *****************************
13554
13555func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
13556 return ec.unmarshalInputAddCommentInput(ctx, v)
13557}
13558
13559func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
13560 return ec._AddCommentOperation(ctx, sel, &v)
13561}
13562
13563func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
13564 if v == nil {
13565 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13566 ec.Errorf(ctx, "must not be null")
13567 }
13568 return graphql.Null
13569 }
13570 return ec._AddCommentOperation(ctx, sel, v)
13571}
13572
13573func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
13574 return ec._AddCommentPayload(ctx, sel, &v)
13575}
13576
13577func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
13578 if v == nil {
13579 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13580 ec.Errorf(ctx, "must not be null")
13581 }
13582 return graphql.Null
13583 }
13584 return ec._AddCommentPayload(ctx, sel, v)
13585}
13586
13587func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
13588 return graphql.UnmarshalBoolean(v)
13589}
13590
13591func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
13592 res := graphql.MarshalBoolean(v)
13593 if res == graphql.Null {
13594 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13595 ec.Errorf(ctx, "must not be null")
13596 }
13597 }
13598 return res
13599}
13600
13601func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
13602 if v == nil {
13603 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13604 ec.Errorf(ctx, "must not be null")
13605 }
13606 return graphql.Null
13607 }
13608 return ec._Bug(ctx, sel, v)
13609}
13610
13611func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
13612 ret := make(graphql.Array, len(v))
13613 var wg sync.WaitGroup
13614 isLen1 := len(v) == 1
13615 if !isLen1 {
13616 wg.Add(len(v))
13617 }
13618 for i := range v {
13619 i := i
13620 fc := &graphql.FieldContext{
13621 Index: &i,
13622 Result: &v[i],
13623 }
13624 ctx := graphql.WithFieldContext(ctx, fc)
13625 f := func(i int) {
13626 defer func() {
13627 if r := recover(); r != nil {
13628 ec.Error(ctx, ec.Recover(ctx, r))
13629 ret = nil
13630 }
13631 }()
13632 if !isLen1 {
13633 defer wg.Done()
13634 }
13635 ret[i] = ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
13636 }
13637 if isLen1 {
13638 f(i)
13639 } else {
13640 go f(i)
13641 }
13642
13643 }
13644 wg.Wait()
13645 return ret
13646}
13647
13648func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
13649 return ec._BugConnection(ctx, sel, &v)
13650}
13651
13652func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
13653 if v == nil {
13654 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13655 ec.Errorf(ctx, "must not be null")
13656 }
13657 return graphql.Null
13658 }
13659 return ec._BugConnection(ctx, sel, v)
13660}
13661
13662func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
13663 return ec._BugEdge(ctx, sel, &v)
13664}
13665
13666func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
13667 ret := make(graphql.Array, len(v))
13668 var wg sync.WaitGroup
13669 isLen1 := len(v) == 1
13670 if !isLen1 {
13671 wg.Add(len(v))
13672 }
13673 for i := range v {
13674 i := i
13675 fc := &graphql.FieldContext{
13676 Index: &i,
13677 Result: &v[i],
13678 }
13679 ctx := graphql.WithFieldContext(ctx, fc)
13680 f := func(i int) {
13681 defer func() {
13682 if r := recover(); r != nil {
13683 ec.Error(ctx, ec.Recover(ctx, r))
13684 ret = nil
13685 }
13686 }()
13687 if !isLen1 {
13688 defer wg.Done()
13689 }
13690 ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
13691 }
13692 if isLen1 {
13693 f(i)
13694 } else {
13695 go f(i)
13696 }
13697
13698 }
13699 wg.Wait()
13700 return ret
13701}
13702
13703func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
13704 if v == nil {
13705 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13706 ec.Errorf(ctx, "must not be null")
13707 }
13708 return graphql.Null
13709 }
13710 return ec._BugEdge(ctx, sel, v)
13711}
13712
13713func (ec *executionContext) unmarshalNChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
13714 return ec.unmarshalInputChangeLabelInput(ctx, v)
13715}
13716
13717func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
13718 return ec._ChangeLabelPayload(ctx, sel, &v)
13719}
13720
13721func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
13722 if v == nil {
13723 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13724 ec.Errorf(ctx, "must not be null")
13725 }
13726 return graphql.Null
13727 }
13728 return ec._ChangeLabelPayload(ctx, sel, v)
13729}
13730
13731func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
13732 return ec.unmarshalInputCloseBugInput(ctx, v)
13733}
13734
13735func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
13736 return ec._CloseBugPayload(ctx, sel, &v)
13737}
13738
13739func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
13740 if v == nil {
13741 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13742 ec.Errorf(ctx, "must not be null")
13743 }
13744 return graphql.Null
13745 }
13746 return ec._CloseBugPayload(ctx, sel, v)
13747}
13748
13749func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
13750 return ec._Color(ctx, sel, &v)
13751}
13752
13753func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
13754 if v == nil {
13755 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13756 ec.Errorf(ctx, "must not be null")
13757 }
13758 return graphql.Null
13759 }
13760 return ec._Color(ctx, sel, v)
13761}
13762
13763func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
13764 return ec._Comment(ctx, sel, &v)
13765}
13766
13767func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
13768 ret := make(graphql.Array, len(v))
13769 var wg sync.WaitGroup
13770 isLen1 := len(v) == 1
13771 if !isLen1 {
13772 wg.Add(len(v))
13773 }
13774 for i := range v {
13775 i := i
13776 fc := &graphql.FieldContext{
13777 Index: &i,
13778 Result: &v[i],
13779 }
13780 ctx := graphql.WithFieldContext(ctx, fc)
13781 f := func(i int) {
13782 defer func() {
13783 if r := recover(); r != nil {
13784 ec.Error(ctx, ec.Recover(ctx, r))
13785 ret = nil
13786 }
13787 }()
13788 if !isLen1 {
13789 defer wg.Done()
13790 }
13791 ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
13792 }
13793 if isLen1 {
13794 f(i)
13795 } else {
13796 go f(i)
13797 }
13798
13799 }
13800 wg.Wait()
13801 return ret
13802}
13803
13804func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
13805 if v == nil {
13806 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13807 ec.Errorf(ctx, "must not be null")
13808 }
13809 return graphql.Null
13810 }
13811 return ec._Comment(ctx, sel, v)
13812}
13813
13814func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
13815 return ec._CommentConnection(ctx, sel, &v)
13816}
13817
13818func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
13819 if v == nil {
13820 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13821 ec.Errorf(ctx, "must not be null")
13822 }
13823 return graphql.Null
13824 }
13825 return ec._CommentConnection(ctx, sel, v)
13826}
13827
13828func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
13829 return ec._CommentEdge(ctx, sel, &v)
13830}
13831
13832func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
13833 ret := make(graphql.Array, len(v))
13834 var wg sync.WaitGroup
13835 isLen1 := len(v) == 1
13836 if !isLen1 {
13837 wg.Add(len(v))
13838 }
13839 for i := range v {
13840 i := i
13841 fc := &graphql.FieldContext{
13842 Index: &i,
13843 Result: &v[i],
13844 }
13845 ctx := graphql.WithFieldContext(ctx, fc)
13846 f := func(i int) {
13847 defer func() {
13848 if r := recover(); r != nil {
13849 ec.Error(ctx, ec.Recover(ctx, r))
13850 ret = nil
13851 }
13852 }()
13853 if !isLen1 {
13854 defer wg.Done()
13855 }
13856 ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
13857 }
13858 if isLen1 {
13859 f(i)
13860 } else {
13861 go f(i)
13862 }
13863
13864 }
13865 wg.Wait()
13866 return ret
13867}
13868
13869func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
13870 if v == nil {
13871 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13872 ec.Errorf(ctx, "must not be null")
13873 }
13874 return graphql.Null
13875 }
13876 return ec._CommentEdge(ctx, sel, v)
13877}
13878
13879func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
13880 return ec._CommentHistoryStep(ctx, sel, &v)
13881}
13882
13883func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
13884 ret := make(graphql.Array, len(v))
13885 var wg sync.WaitGroup
13886 isLen1 := len(v) == 1
13887 if !isLen1 {
13888 wg.Add(len(v))
13889 }
13890 for i := range v {
13891 i := i
13892 fc := &graphql.FieldContext{
13893 Index: &i,
13894 Result: &v[i],
13895 }
13896 ctx := graphql.WithFieldContext(ctx, fc)
13897 f := func(i int) {
13898 defer func() {
13899 if r := recover(); r != nil {
13900 ec.Error(ctx, ec.Recover(ctx, r))
13901 ret = nil
13902 }
13903 }()
13904 if !isLen1 {
13905 defer wg.Done()
13906 }
13907 ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
13908 }
13909 if isLen1 {
13910 f(i)
13911 } else {
13912 go f(i)
13913 }
13914
13915 }
13916 wg.Wait()
13917 return ret
13918}
13919
13920func (ec *executionContext) unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx context.Context, v interface{}) (models.CommitInput, error) {
13921 return ec.unmarshalInputCommitInput(ctx, v)
13922}
13923
13924func (ec *executionContext) marshalNCommitPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitPayload) graphql.Marshaler {
13925 return ec._CommitPayload(ctx, sel, &v)
13926}
13927
13928func (ec *executionContext) marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitPayload) graphql.Marshaler {
13929 if v == nil {
13930 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13931 ec.Errorf(ctx, "must not be null")
13932 }
13933 return graphql.Null
13934 }
13935 return ec._CommitPayload(ctx, sel, v)
13936}
13937
13938func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
13939 return ec._CreateOperation(ctx, sel, &v)
13940}
13941
13942func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
13943 if v == nil {
13944 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13945 ec.Errorf(ctx, "must not be null")
13946 }
13947 return graphql.Null
13948 }
13949 return ec._CreateOperation(ctx, sel, v)
13950}
13951
13952func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
13953 var res git.Hash
13954 return res, res.UnmarshalGQL(v)
13955}
13956
13957func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
13958 return v
13959}
13960
13961func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
13962 var vSlice []interface{}
13963 if v != nil {
13964 if tmp1, ok := v.([]interface{}); ok {
13965 vSlice = tmp1
13966 } else {
13967 vSlice = []interface{}{v}
13968 }
13969 }
13970 var err error
13971 res := make([]git.Hash, len(vSlice))
13972 for i := range vSlice {
13973 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
13974 if err != nil {
13975 return nil, err
13976 }
13977 }
13978 return res, nil
13979}
13980
13981func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
13982 ret := make(graphql.Array, len(v))
13983 for i := range v {
13984 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
13985 }
13986
13987 return ret
13988}
13989
13990func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
13991 if v == nil {
13992 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13993 ec.Errorf(ctx, "must not be null")
13994 }
13995 return graphql.Null
13996 }
13997 return ec._Identity(ctx, sel, v)
13998}
13999
14000func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.IdentityWrapper) graphql.Marshaler {
14001 ret := make(graphql.Array, len(v))
14002 var wg sync.WaitGroup
14003 isLen1 := len(v) == 1
14004 if !isLen1 {
14005 wg.Add(len(v))
14006 }
14007 for i := range v {
14008 i := i
14009 fc := &graphql.FieldContext{
14010 Index: &i,
14011 Result: &v[i],
14012 }
14013 ctx := graphql.WithFieldContext(ctx, fc)
14014 f := func(i int) {
14015 defer func() {
14016 if r := recover(); r != nil {
14017 ec.Error(ctx, ec.Recover(ctx, r))
14018 ret = nil
14019 }
14020 }()
14021 if !isLen1 {
14022 defer wg.Done()
14023 }
14024 ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, sel, v[i])
14025 }
14026 if isLen1 {
14027 f(i)
14028 } else {
14029 go f(i)
14030 }
14031
14032 }
14033 wg.Wait()
14034 return ret
14035}
14036
14037func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
14038 return ec._IdentityConnection(ctx, sel, &v)
14039}
14040
14041func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
14042 if v == nil {
14043 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14044 ec.Errorf(ctx, "must not be null")
14045 }
14046 return graphql.Null
14047 }
14048 return ec._IdentityConnection(ctx, sel, v)
14049}
14050
14051func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
14052 return ec._IdentityEdge(ctx, sel, &v)
14053}
14054
14055func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
14056 ret := make(graphql.Array, len(v))
14057 var wg sync.WaitGroup
14058 isLen1 := len(v) == 1
14059 if !isLen1 {
14060 wg.Add(len(v))
14061 }
14062 for i := range v {
14063 i := i
14064 fc := &graphql.FieldContext{
14065 Index: &i,
14066 Result: &v[i],
14067 }
14068 ctx := graphql.WithFieldContext(ctx, fc)
14069 f := func(i int) {
14070 defer func() {
14071 if r := recover(); r != nil {
14072 ec.Error(ctx, ec.Recover(ctx, r))
14073 ret = nil
14074 }
14075 }()
14076 if !isLen1 {
14077 defer wg.Done()
14078 }
14079 ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
14080 }
14081 if isLen1 {
14082 f(i)
14083 } else {
14084 go f(i)
14085 }
14086
14087 }
14088 wg.Wait()
14089 return ret
14090}
14091
14092func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
14093 if v == nil {
14094 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14095 ec.Errorf(ctx, "must not be null")
14096 }
14097 return graphql.Null
14098 }
14099 return ec._IdentityEdge(ctx, sel, v)
14100}
14101
14102func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
14103 return graphql.UnmarshalInt(v)
14104}
14105
14106func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14107 res := graphql.MarshalInt(v)
14108 if res == graphql.Null {
14109 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14110 ec.Errorf(ctx, "must not be null")
14111 }
14112 }
14113 return res
14114}
14115
14116func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
14117 return ec._Label(ctx, sel, &v)
14118}
14119
14120func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
14121 ret := make(graphql.Array, len(v))
14122 var wg sync.WaitGroup
14123 isLen1 := len(v) == 1
14124 if !isLen1 {
14125 wg.Add(len(v))
14126 }
14127 for i := range v {
14128 i := i
14129 fc := &graphql.FieldContext{
14130 Index: &i,
14131 Result: &v[i],
14132 }
14133 ctx := graphql.WithFieldContext(ctx, fc)
14134 f := func(i int) {
14135 defer func() {
14136 if r := recover(); r != nil {
14137 ec.Error(ctx, ec.Recover(ctx, r))
14138 ret = nil
14139 }
14140 }()
14141 if !isLen1 {
14142 defer wg.Done()
14143 }
14144 ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
14145 }
14146 if isLen1 {
14147 f(i)
14148 } else {
14149 go f(i)
14150 }
14151
14152 }
14153 wg.Wait()
14154 return ret
14155}
14156
14157func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
14158 return ec._LabelChangeOperation(ctx, sel, &v)
14159}
14160
14161func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
14162 if v == nil {
14163 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14164 ec.Errorf(ctx, "must not be null")
14165 }
14166 return graphql.Null
14167 }
14168 return ec._LabelChangeOperation(ctx, sel, v)
14169}
14170
14171func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
14172 ret := make(graphql.Array, len(v))
14173 var wg sync.WaitGroup
14174 isLen1 := len(v) == 1
14175 if !isLen1 {
14176 wg.Add(len(v))
14177 }
14178 for i := range v {
14179 i := i
14180 fc := &graphql.FieldContext{
14181 Index: &i,
14182 Result: &v[i],
14183 }
14184 ctx := graphql.WithFieldContext(ctx, fc)
14185 f := func(i int) {
14186 defer func() {
14187 if r := recover(); r != nil {
14188 ec.Error(ctx, ec.Recover(ctx, r))
14189 ret = nil
14190 }
14191 }()
14192 if !isLen1 {
14193 defer wg.Done()
14194 }
14195 ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
14196 }
14197 if isLen1 {
14198 f(i)
14199 } else {
14200 go f(i)
14201 }
14202
14203 }
14204 wg.Wait()
14205 return ret
14206}
14207
14208func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
14209 var res models.LabelChangeStatus
14210 return res, res.UnmarshalGQL(v)
14211}
14212
14213func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
14214 return v
14215}
14216
14217func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
14218 return ec._LabelConnection(ctx, sel, &v)
14219}
14220
14221func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
14222 if v == nil {
14223 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14224 ec.Errorf(ctx, "must not be null")
14225 }
14226 return graphql.Null
14227 }
14228 return ec._LabelConnection(ctx, sel, v)
14229}
14230
14231func (ec *executionContext) marshalNLabelEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v models.LabelEdge) graphql.Marshaler {
14232 return ec._LabelEdge(ctx, sel, &v)
14233}
14234
14235func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
14236 ret := make(graphql.Array, len(v))
14237 var wg sync.WaitGroup
14238 isLen1 := len(v) == 1
14239 if !isLen1 {
14240 wg.Add(len(v))
14241 }
14242 for i := range v {
14243 i := i
14244 fc := &graphql.FieldContext{
14245 Index: &i,
14246 Result: &v[i],
14247 }
14248 ctx := graphql.WithFieldContext(ctx, fc)
14249 f := func(i int) {
14250 defer func() {
14251 if r := recover(); r != nil {
14252 ec.Error(ctx, ec.Recover(ctx, r))
14253 ret = nil
14254 }
14255 }()
14256 if !isLen1 {
14257 defer wg.Done()
14258 }
14259 ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
14260 }
14261 if isLen1 {
14262 f(i)
14263 } else {
14264 go f(i)
14265 }
14266
14267 }
14268 wg.Wait()
14269 return ret
14270}
14271
14272func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
14273 if v == nil {
14274 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14275 ec.Errorf(ctx, "must not be null")
14276 }
14277 return graphql.Null
14278 }
14279 return ec._LabelEdge(ctx, sel, v)
14280}
14281
14282func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
14283 return ec.unmarshalInputNewBugInput(ctx, v)
14284}
14285
14286func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
14287 return ec._NewBugPayload(ctx, sel, &v)
14288}
14289
14290func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
14291 if v == nil {
14292 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14293 ec.Errorf(ctx, "must not be null")
14294 }
14295 return graphql.Null
14296 }
14297 return ec._NewBugPayload(ctx, sel, v)
14298}
14299
14300func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
14301 return ec.unmarshalInputOpenBugInput(ctx, v)
14302}
14303
14304func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
14305 return ec._OpenBugPayload(ctx, sel, &v)
14306}
14307
14308func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
14309 if v == nil {
14310 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14311 ec.Errorf(ctx, "must not be null")
14312 }
14313 return graphql.Null
14314 }
14315 return ec._OpenBugPayload(ctx, sel, v)
14316}
14317
14318func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
14319 if v == nil {
14320 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14321 ec.Errorf(ctx, "must not be null")
14322 }
14323 return graphql.Null
14324 }
14325 return ec._Operation(ctx, sel, v)
14326}
14327
14328func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
14329 ret := make(graphql.Array, len(v))
14330 var wg sync.WaitGroup
14331 isLen1 := len(v) == 1
14332 if !isLen1 {
14333 wg.Add(len(v))
14334 }
14335 for i := range v {
14336 i := i
14337 fc := &graphql.FieldContext{
14338 Index: &i,
14339 Result: &v[i],
14340 }
14341 ctx := graphql.WithFieldContext(ctx, fc)
14342 f := func(i int) {
14343 defer func() {
14344 if r := recover(); r != nil {
14345 ec.Error(ctx, ec.Recover(ctx, r))
14346 ret = nil
14347 }
14348 }()
14349 if !isLen1 {
14350 defer wg.Done()
14351 }
14352 ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
14353 }
14354 if isLen1 {
14355 f(i)
14356 } else {
14357 go f(i)
14358 }
14359
14360 }
14361 wg.Wait()
14362 return ret
14363}
14364
14365func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
14366 return ec._OperationConnection(ctx, sel, &v)
14367}
14368
14369func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
14370 if v == nil {
14371 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14372 ec.Errorf(ctx, "must not be null")
14373 }
14374 return graphql.Null
14375 }
14376 return ec._OperationConnection(ctx, sel, v)
14377}
14378
14379func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
14380 return ec._OperationEdge(ctx, sel, &v)
14381}
14382
14383func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
14384 ret := make(graphql.Array, len(v))
14385 var wg sync.WaitGroup
14386 isLen1 := len(v) == 1
14387 if !isLen1 {
14388 wg.Add(len(v))
14389 }
14390 for i := range v {
14391 i := i
14392 fc := &graphql.FieldContext{
14393 Index: &i,
14394 Result: &v[i],
14395 }
14396 ctx := graphql.WithFieldContext(ctx, fc)
14397 f := func(i int) {
14398 defer func() {
14399 if r := recover(); r != nil {
14400 ec.Error(ctx, ec.Recover(ctx, r))
14401 ret = nil
14402 }
14403 }()
14404 if !isLen1 {
14405 defer wg.Done()
14406 }
14407 ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
14408 }
14409 if isLen1 {
14410 f(i)
14411 } else {
14412 go f(i)
14413 }
14414
14415 }
14416 wg.Wait()
14417 return ret
14418}
14419
14420func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
14421 if v == nil {
14422 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14423 ec.Errorf(ctx, "must not be null")
14424 }
14425 return graphql.Null
14426 }
14427 return ec._OperationEdge(ctx, sel, v)
14428}
14429
14430func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
14431 return ec._PageInfo(ctx, sel, &v)
14432}
14433
14434func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
14435 if v == nil {
14436 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14437 ec.Errorf(ctx, "must not be null")
14438 }
14439 return graphql.Null
14440 }
14441 return ec._PageInfo(ctx, sel, v)
14442}
14443
14444func (ec *executionContext) unmarshalNRollbackInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRollbackInput(ctx context.Context, v interface{}) (models.RollbackInput, error) {
14445 return ec.unmarshalInputRollbackInput(ctx, v)
14446}
14447
14448func (ec *executionContext) marshalNRollbackPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRollbackPayload(ctx context.Context, sel ast.SelectionSet, v models.RollbackPayload) graphql.Marshaler {
14449 return ec._RollbackPayload(ctx, sel, &v)
14450}
14451
14452func (ec *executionContext) marshalNRollbackPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRollbackPayload(ctx context.Context, sel ast.SelectionSet, v *models.RollbackPayload) graphql.Marshaler {
14453 if v == nil {
14454 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14455 ec.Errorf(ctx, "must not be null")
14456 }
14457 return graphql.Null
14458 }
14459 return ec._RollbackPayload(ctx, sel, v)
14460}
14461
14462func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
14463 return ec._SetStatusOperation(ctx, sel, &v)
14464}
14465
14466func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
14467 if v == nil {
14468 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14469 ec.Errorf(ctx, "must not be null")
14470 }
14471 return graphql.Null
14472 }
14473 return ec._SetStatusOperation(ctx, sel, v)
14474}
14475
14476func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
14477 return ec.unmarshalInputSetTitleInput(ctx, v)
14478}
14479
14480func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
14481 return ec._SetTitleOperation(ctx, sel, &v)
14482}
14483
14484func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
14485 if v == nil {
14486 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14487 ec.Errorf(ctx, "must not be null")
14488 }
14489 return graphql.Null
14490 }
14491 return ec._SetTitleOperation(ctx, sel, v)
14492}
14493
14494func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
14495 return ec._SetTitlePayload(ctx, sel, &v)
14496}
14497
14498func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
14499 if v == nil {
14500 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14501 ec.Errorf(ctx, "must not be null")
14502 }
14503 return graphql.Null
14504 }
14505 return ec._SetTitlePayload(ctx, sel, v)
14506}
14507
14508func (ec *executionContext) unmarshalNStartTransactionInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStartTransactionInput(ctx context.Context, v interface{}) (models.StartTransactionInput, error) {
14509 return ec.unmarshalInputStartTransactionInput(ctx, v)
14510}
14511
14512func (ec *executionContext) marshalNStartTransactionPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStartTransactionPayload(ctx context.Context, sel ast.SelectionSet, v models.StartTransactionPayload) graphql.Marshaler {
14513 return ec._StartTransactionPayload(ctx, sel, &v)
14514}
14515
14516func (ec *executionContext) marshalNStartTransactionPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStartTransactionPayload(ctx context.Context, sel ast.SelectionSet, v *models.StartTransactionPayload) graphql.Marshaler {
14517 if v == nil {
14518 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14519 ec.Errorf(ctx, "must not be null")
14520 }
14521 return graphql.Null
14522 }
14523 return ec._StartTransactionPayload(ctx, sel, v)
14524}
14525
14526func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
14527 var res models.Status
14528 return res, res.UnmarshalGQL(v)
14529}
14530
14531func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
14532 return v
14533}
14534
14535func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
14536 return graphql.UnmarshalString(v)
14537}
14538
14539func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14540 res := graphql.MarshalString(v)
14541 if res == graphql.Null {
14542 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14543 ec.Errorf(ctx, "must not be null")
14544 }
14545 }
14546 return res
14547}
14548
14549func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
14550 return graphql.UnmarshalTime(v)
14551}
14552
14553func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
14554 res := graphql.MarshalTime(v)
14555 if res == graphql.Null {
14556 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14557 ec.Errorf(ctx, "must not be null")
14558 }
14559 }
14560 return res
14561}
14562
14563func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
14564 if v == nil {
14565 return nil, nil
14566 }
14567 res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
14568 return &res, err
14569}
14570
14571func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
14572 if v == nil {
14573 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14574 ec.Errorf(ctx, "must not be null")
14575 }
14576 return graphql.Null
14577 }
14578 return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
14579}
14580
14581func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
14582 if v == nil {
14583 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14584 ec.Errorf(ctx, "must not be null")
14585 }
14586 return graphql.Null
14587 }
14588 return ec._TimelineItem(ctx, sel, v)
14589}
14590
14591func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
14592 ret := make(graphql.Array, len(v))
14593 var wg sync.WaitGroup
14594 isLen1 := len(v) == 1
14595 if !isLen1 {
14596 wg.Add(len(v))
14597 }
14598 for i := range v {
14599 i := i
14600 fc := &graphql.FieldContext{
14601 Index: &i,
14602 Result: &v[i],
14603 }
14604 ctx := graphql.WithFieldContext(ctx, fc)
14605 f := func(i int) {
14606 defer func() {
14607 if r := recover(); r != nil {
14608 ec.Error(ctx, ec.Recover(ctx, r))
14609 ret = nil
14610 }
14611 }()
14612 if !isLen1 {
14613 defer wg.Done()
14614 }
14615 ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
14616 }
14617 if isLen1 {
14618 f(i)
14619 } else {
14620 go f(i)
14621 }
14622
14623 }
14624 wg.Wait()
14625 return ret
14626}
14627
14628func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
14629 return ec._TimelineItemConnection(ctx, sel, &v)
14630}
14631
14632func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
14633 if v == nil {
14634 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14635 ec.Errorf(ctx, "must not be null")
14636 }
14637 return graphql.Null
14638 }
14639 return ec._TimelineItemConnection(ctx, sel, v)
14640}
14641
14642func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
14643 return ec._TimelineItemEdge(ctx, sel, &v)
14644}
14645
14646func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
14647 ret := make(graphql.Array, len(v))
14648 var wg sync.WaitGroup
14649 isLen1 := len(v) == 1
14650 if !isLen1 {
14651 wg.Add(len(v))
14652 }
14653 for i := range v {
14654 i := i
14655 fc := &graphql.FieldContext{
14656 Index: &i,
14657 Result: &v[i],
14658 }
14659 ctx := graphql.WithFieldContext(ctx, fc)
14660 f := func(i int) {
14661 defer func() {
14662 if r := recover(); r != nil {
14663 ec.Error(ctx, ec.Recover(ctx, r))
14664 ret = nil
14665 }
14666 }()
14667 if !isLen1 {
14668 defer wg.Done()
14669 }
14670 ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
14671 }
14672 if isLen1 {
14673 f(i)
14674 } else {
14675 go f(i)
14676 }
14677
14678 }
14679 wg.Wait()
14680 return ret
14681}
14682
14683func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
14684 if v == nil {
14685 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14686 ec.Errorf(ctx, "must not be null")
14687 }
14688 return graphql.Null
14689 }
14690 return ec._TimelineItemEdge(ctx, sel, v)
14691}
14692
14693func (ec *executionContext) unmarshalNTxId2string(ctx context.Context, v interface{}) (string, error) {
14694 return graphql.UnmarshalString(v)
14695}
14696
14697func (ec *executionContext) marshalNTxId2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14698 res := graphql.MarshalString(v)
14699 if res == graphql.Null {
14700 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14701 ec.Errorf(ctx, "must not be null")
14702 }
14703 }
14704 return res
14705}
14706
14707func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
14708 return ec.___Directive(ctx, sel, &v)
14709}
14710
14711func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
14712 ret := make(graphql.Array, len(v))
14713 var wg sync.WaitGroup
14714 isLen1 := len(v) == 1
14715 if !isLen1 {
14716 wg.Add(len(v))
14717 }
14718 for i := range v {
14719 i := i
14720 fc := &graphql.FieldContext{
14721 Index: &i,
14722 Result: &v[i],
14723 }
14724 ctx := graphql.WithFieldContext(ctx, fc)
14725 f := func(i int) {
14726 defer func() {
14727 if r := recover(); r != nil {
14728 ec.Error(ctx, ec.Recover(ctx, r))
14729 ret = nil
14730 }
14731 }()
14732 if !isLen1 {
14733 defer wg.Done()
14734 }
14735 ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
14736 }
14737 if isLen1 {
14738 f(i)
14739 } else {
14740 go f(i)
14741 }
14742
14743 }
14744 wg.Wait()
14745 return ret
14746}
14747
14748func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
14749 return graphql.UnmarshalString(v)
14750}
14751
14752func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14753 res := graphql.MarshalString(v)
14754 if res == graphql.Null {
14755 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14756 ec.Errorf(ctx, "must not be null")
14757 }
14758 }
14759 return res
14760}
14761
14762func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14763 var vSlice []interface{}
14764 if v != nil {
14765 if tmp1, ok := v.([]interface{}); ok {
14766 vSlice = tmp1
14767 } else {
14768 vSlice = []interface{}{v}
14769 }
14770 }
14771 var err error
14772 res := make([]string, len(vSlice))
14773 for i := range vSlice {
14774 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
14775 if err != nil {
14776 return nil, err
14777 }
14778 }
14779 return res, nil
14780}
14781
14782func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14783 ret := make(graphql.Array, len(v))
14784 var wg sync.WaitGroup
14785 isLen1 := len(v) == 1
14786 if !isLen1 {
14787 wg.Add(len(v))
14788 }
14789 for i := range v {
14790 i := i
14791 fc := &graphql.FieldContext{
14792 Index: &i,
14793 Result: &v[i],
14794 }
14795 ctx := graphql.WithFieldContext(ctx, fc)
14796 f := func(i int) {
14797 defer func() {
14798 if r := recover(); r != nil {
14799 ec.Error(ctx, ec.Recover(ctx, r))
14800 ret = nil
14801 }
14802 }()
14803 if !isLen1 {
14804 defer wg.Done()
14805 }
14806 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
14807 }
14808 if isLen1 {
14809 f(i)
14810 } else {
14811 go f(i)
14812 }
14813
14814 }
14815 wg.Wait()
14816 return ret
14817}
14818
14819func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
14820 return ec.___EnumValue(ctx, sel, &v)
14821}
14822
14823func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
14824 return ec.___Field(ctx, sel, &v)
14825}
14826
14827func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
14828 return ec.___InputValue(ctx, sel, &v)
14829}
14830
14831func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14832 ret := make(graphql.Array, len(v))
14833 var wg sync.WaitGroup
14834 isLen1 := len(v) == 1
14835 if !isLen1 {
14836 wg.Add(len(v))
14837 }
14838 for i := range v {
14839 i := i
14840 fc := &graphql.FieldContext{
14841 Index: &i,
14842 Result: &v[i],
14843 }
14844 ctx := graphql.WithFieldContext(ctx, fc)
14845 f := func(i int) {
14846 defer func() {
14847 if r := recover(); r != nil {
14848 ec.Error(ctx, ec.Recover(ctx, r))
14849 ret = nil
14850 }
14851 }()
14852 if !isLen1 {
14853 defer wg.Done()
14854 }
14855 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14856 }
14857 if isLen1 {
14858 f(i)
14859 } else {
14860 go f(i)
14861 }
14862
14863 }
14864 wg.Wait()
14865 return ret
14866}
14867
14868func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14869 return ec.___Type(ctx, sel, &v)
14870}
14871
14872func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14873 ret := make(graphql.Array, len(v))
14874 var wg sync.WaitGroup
14875 isLen1 := len(v) == 1
14876 if !isLen1 {
14877 wg.Add(len(v))
14878 }
14879 for i := range v {
14880 i := i
14881 fc := &graphql.FieldContext{
14882 Index: &i,
14883 Result: &v[i],
14884 }
14885 ctx := graphql.WithFieldContext(ctx, fc)
14886 f := func(i int) {
14887 defer func() {
14888 if r := recover(); r != nil {
14889 ec.Error(ctx, ec.Recover(ctx, r))
14890 ret = nil
14891 }
14892 }()
14893 if !isLen1 {
14894 defer wg.Done()
14895 }
14896 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14897 }
14898 if isLen1 {
14899 f(i)
14900 } else {
14901 go f(i)
14902 }
14903
14904 }
14905 wg.Wait()
14906 return ret
14907}
14908
14909func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14910 if v == nil {
14911 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14912 ec.Errorf(ctx, "must not be null")
14913 }
14914 return graphql.Null
14915 }
14916 return ec.___Type(ctx, sel, v)
14917}
14918
14919func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
14920 return graphql.UnmarshalString(v)
14921}
14922
14923func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14924 res := graphql.MarshalString(v)
14925 if res == graphql.Null {
14926 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14927 ec.Errorf(ctx, "must not be null")
14928 }
14929 }
14930 return res
14931}
14932
14933func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
14934 return graphql.UnmarshalBoolean(v)
14935}
14936
14937func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
14938 return graphql.MarshalBoolean(v)
14939}
14940
14941func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
14942 if v == nil {
14943 return nil, nil
14944 }
14945 res, err := ec.unmarshalOBoolean2bool(ctx, v)
14946 return &res, err
14947}
14948
14949func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
14950 if v == nil {
14951 return graphql.Null
14952 }
14953 return ec.marshalOBoolean2bool(ctx, sel, *v)
14954}
14955
14956func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
14957 if v == nil {
14958 return graphql.Null
14959 }
14960 return ec._Bug(ctx, sel, v)
14961}
14962
14963func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
14964 var vSlice []interface{}
14965 if v != nil {
14966 if tmp1, ok := v.([]interface{}); ok {
14967 vSlice = tmp1
14968 } else {
14969 vSlice = []interface{}{v}
14970 }
14971 }
14972 var err error
14973 res := make([]git.Hash, len(vSlice))
14974 for i := range vSlice {
14975 res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
14976 if err != nil {
14977 return nil, err
14978 }
14979 }
14980 return res, nil
14981}
14982
14983func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
14984 if v == nil {
14985 return graphql.Null
14986 }
14987 ret := make(graphql.Array, len(v))
14988 for i := range v {
14989 ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
14990 }
14991
14992 return ret
14993}
14994
14995func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
14996 if v == nil {
14997 return graphql.Null
14998 }
14999 return ec._Identity(ctx, sel, v)
15000}
15001
15002func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
15003 return graphql.UnmarshalInt(v)
15004}
15005
15006func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
15007 return graphql.MarshalInt(v)
15008}
15009
15010func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
15011 if v == nil {
15012 return nil, nil
15013 }
15014 res, err := ec.unmarshalOInt2int(ctx, v)
15015 return &res, err
15016}
15017
15018func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
15019 if v == nil {
15020 return graphql.Null
15021 }
15022 return ec.marshalOInt2int(ctx, sel, *v)
15023}
15024
15025func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
15026 return ec._LabelChangeResult(ctx, sel, &v)
15027}
15028
15029func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
15030 if v == nil {
15031 return graphql.Null
15032 }
15033 return ec._LabelChangeResult(ctx, sel, v)
15034}
15035
15036func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
15037 return ec._Repository(ctx, sel, &v)
15038}
15039
15040func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
15041 if v == nil {
15042 return graphql.Null
15043 }
15044 return ec._Repository(ctx, sel, v)
15045}
15046
15047func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
15048 return graphql.UnmarshalString(v)
15049}
15050
15051func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
15052 return graphql.MarshalString(v)
15053}
15054
15055func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
15056 var vSlice []interface{}
15057 if v != nil {
15058 if tmp1, ok := v.([]interface{}); ok {
15059 vSlice = tmp1
15060 } else {
15061 vSlice = []interface{}{v}
15062 }
15063 }
15064 var err error
15065 res := make([]string, len(vSlice))
15066 for i := range vSlice {
15067 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
15068 if err != nil {
15069 return nil, err
15070 }
15071 }
15072 return res, nil
15073}
15074
15075func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
15076 if v == nil {
15077 return graphql.Null
15078 }
15079 ret := make(graphql.Array, len(v))
15080 for i := range v {
15081 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
15082 }
15083
15084 return ret
15085}
15086
15087func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
15088 if v == nil {
15089 return nil, nil
15090 }
15091 res, err := ec.unmarshalOString2string(ctx, v)
15092 return &res, err
15093}
15094
15095func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
15096 if v == nil {
15097 return graphql.Null
15098 }
15099 return ec.marshalOString2string(ctx, sel, *v)
15100}
15101
15102func (ec *executionContext) unmarshalOTxId2string(ctx context.Context, v interface{}) (string, error) {
15103 return graphql.UnmarshalString(v)
15104}
15105
15106func (ec *executionContext) marshalOTxId2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
15107 return graphql.MarshalString(v)
15108}
15109
15110func (ec *executionContext) unmarshalOTxId2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
15111 if v == nil {
15112 return nil, nil
15113 }
15114 res, err := ec.unmarshalOTxId2string(ctx, v)
15115 return &res, err
15116}
15117
15118func (ec *executionContext) marshalOTxId2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
15119 if v == nil {
15120 return graphql.Null
15121 }
15122 return ec.marshalOTxId2string(ctx, sel, *v)
15123}
15124
15125func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
15126 if v == nil {
15127 return graphql.Null
15128 }
15129 ret := make(graphql.Array, len(v))
15130 var wg sync.WaitGroup
15131 isLen1 := len(v) == 1
15132 if !isLen1 {
15133 wg.Add(len(v))
15134 }
15135 for i := range v {
15136 i := i
15137 fc := &graphql.FieldContext{
15138 Index: &i,
15139 Result: &v[i],
15140 }
15141 ctx := graphql.WithFieldContext(ctx, fc)
15142 f := func(i int) {
15143 defer func() {
15144 if r := recover(); r != nil {
15145 ec.Error(ctx, ec.Recover(ctx, r))
15146 ret = nil
15147 }
15148 }()
15149 if !isLen1 {
15150 defer wg.Done()
15151 }
15152 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
15153 }
15154 if isLen1 {
15155 f(i)
15156 } else {
15157 go f(i)
15158 }
15159
15160 }
15161 wg.Wait()
15162 return ret
15163}
15164
15165func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
15166 if v == nil {
15167 return graphql.Null
15168 }
15169 ret := make(graphql.Array, len(v))
15170 var wg sync.WaitGroup
15171 isLen1 := len(v) == 1
15172 if !isLen1 {
15173 wg.Add(len(v))
15174 }
15175 for i := range v {
15176 i := i
15177 fc := &graphql.FieldContext{
15178 Index: &i,
15179 Result: &v[i],
15180 }
15181 ctx := graphql.WithFieldContext(ctx, fc)
15182 f := func(i int) {
15183 defer func() {
15184 if r := recover(); r != nil {
15185 ec.Error(ctx, ec.Recover(ctx, r))
15186 ret = nil
15187 }
15188 }()
15189 if !isLen1 {
15190 defer wg.Done()
15191 }
15192 ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
15193 }
15194 if isLen1 {
15195 f(i)
15196 } else {
15197 go f(i)
15198 }
15199
15200 }
15201 wg.Wait()
15202 return ret
15203}
15204
15205func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
15206 if v == nil {
15207 return graphql.Null
15208 }
15209 ret := make(graphql.Array, len(v))
15210 var wg sync.WaitGroup
15211 isLen1 := len(v) == 1
15212 if !isLen1 {
15213 wg.Add(len(v))
15214 }
15215 for i := range v {
15216 i := i
15217 fc := &graphql.FieldContext{
15218 Index: &i,
15219 Result: &v[i],
15220 }
15221 ctx := graphql.WithFieldContext(ctx, fc)
15222 f := func(i int) {
15223 defer func() {
15224 if r := recover(); r != nil {
15225 ec.Error(ctx, ec.Recover(ctx, r))
15226 ret = nil
15227 }
15228 }()
15229 if !isLen1 {
15230 defer wg.Done()
15231 }
15232 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
15233 }
15234 if isLen1 {
15235 f(i)
15236 } else {
15237 go f(i)
15238 }
15239
15240 }
15241 wg.Wait()
15242 return ret
15243}
15244
15245func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
15246 return ec.___Schema(ctx, sel, &v)
15247}
15248
15249func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
15250 if v == nil {
15251 return graphql.Null
15252 }
15253 return ec.___Schema(ctx, sel, v)
15254}
15255
15256func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
15257 return ec.___Type(ctx, sel, &v)
15258}
15259
15260func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
15261 if v == nil {
15262 return graphql.Null
15263 }
15264 ret := make(graphql.Array, len(v))
15265 var wg sync.WaitGroup
15266 isLen1 := len(v) == 1
15267 if !isLen1 {
15268 wg.Add(len(v))
15269 }
15270 for i := range v {
15271 i := i
15272 fc := &graphql.FieldContext{
15273 Index: &i,
15274 Result: &v[i],
15275 }
15276 ctx := graphql.WithFieldContext(ctx, fc)
15277 f := func(i int) {
15278 defer func() {
15279 if r := recover(); r != nil {
15280 ec.Error(ctx, ec.Recover(ctx, r))
15281 ret = nil
15282 }
15283 }()
15284 if !isLen1 {
15285 defer wg.Done()
15286 }
15287 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
15288 }
15289 if isLen1 {
15290 f(i)
15291 } else {
15292 go f(i)
15293 }
15294
15295 }
15296 wg.Wait()
15297 return ret
15298}
15299
15300func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
15301 if v == nil {
15302 return graphql.Null
15303 }
15304 return ec.___Type(ctx, sel, v)
15305}
15306
15307// endregion ***************************** type.gotpl *****************************