1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
2
3package graph
4
5import (
6 "context"
7 "errors"
8 "fmt"
9 "strconv"
10 "sync"
11 "sync/atomic"
12 "time"
13
14 "github.com/99designs/gqlgen/graphql"
15 "github.com/git-bug/git-bug/api/graphql/models"
16 "github.com/git-bug/git-bug/entities/bug"
17 "github.com/git-bug/git-bug/entities/common"
18 "github.com/git-bug/git-bug/entity"
19 "github.com/git-bug/git-bug/repository"
20 "github.com/vektah/gqlparser/v2/ast"
21)
22
23// region ************************** generated!.gotpl **************************
24
25type AddCommentTimelineItemResolver interface {
26 ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (entity.CombinedId, error)
27 Author(ctx context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, error)
28
29 CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
30 LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
31}
32type CommentHistoryStepResolver interface {
33 Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
34}
35type CreateTimelineItemResolver interface {
36 ID(ctx context.Context, obj *bug.CreateTimelineItem) (entity.CombinedId, error)
37 Author(ctx context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error)
38
39 CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
40 LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
41}
42type LabelChangeTimelineItemResolver interface {
43 ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (entity.CombinedId, error)
44 Author(ctx context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error)
45 Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
46}
47type SetStatusTimelineItemResolver interface {
48 ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (entity.CombinedId, error)
49 Author(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error)
50 Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
51}
52type SetTitleTimelineItemResolver interface {
53 ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (entity.CombinedId, error)
54 Author(ctx context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error)
55 Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
56}
57
58// endregion ************************** generated!.gotpl **************************
59
60// region ***************************** args.gotpl *****************************
61
62// endregion ***************************** args.gotpl *****************************
63
64// region ************************** directives.gotpl **************************
65
66// endregion ************************** directives.gotpl **************************
67
68// region **************************** field.gotpl *****************************
69
70func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
71 fc, err := ec.fieldContext_AddCommentTimelineItem_id(ctx, field)
72 if err != nil {
73 return graphql.Null
74 }
75 ctx = graphql.WithFieldContext(ctx, fc)
76 defer func() {
77 if r := recover(); r != nil {
78 ec.Error(ctx, ec.Recover(ctx, r))
79 ret = graphql.Null
80 }
81 }()
82 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
83 ctx = rctx // use context from middleware stack in children
84 return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
85 })
86 if err != nil {
87 ec.Error(ctx, err)
88 return graphql.Null
89 }
90 if resTmp == nil {
91 if !graphql.HasFieldError(ctx, fc) {
92 ec.Errorf(ctx, "must not be null")
93 }
94 return graphql.Null
95 }
96 res := resTmp.(entity.CombinedId)
97 fc.Result = res
98 return ec.marshalNCombinedId2githubácomágitábugágitábugáentityáCombinedId(ctx, field.Selections, res)
99}
100
101func (ec *executionContext) fieldContext_AddCommentTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
102 fc = &graphql.FieldContext{
103 Object: "AddCommentTimelineItem",
104 Field: field,
105 IsMethod: true,
106 IsResolver: true,
107 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
108 return nil, errors.New("field of type CombinedId does not have child fields")
109 },
110 }
111 return fc, nil
112}
113
114func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
115 fc, err := ec.fieldContext_AddCommentTimelineItem_author(ctx, field)
116 if err != nil {
117 return graphql.Null
118 }
119 ctx = graphql.WithFieldContext(ctx, fc)
120 defer func() {
121 if r := recover(); r != nil {
122 ec.Error(ctx, ec.Recover(ctx, r))
123 ret = graphql.Null
124 }
125 }()
126 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
127 ctx = rctx // use context from middleware stack in children
128 return ec.resolvers.AddCommentTimelineItem().Author(rctx, obj)
129 })
130 if err != nil {
131 ec.Error(ctx, err)
132 return graphql.Null
133 }
134 if resTmp == nil {
135 if !graphql.HasFieldError(ctx, fc) {
136 ec.Errorf(ctx, "must not be null")
137 }
138 return graphql.Null
139 }
140 res := resTmp.(models.IdentityWrapper)
141 fc.Result = res
142 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
143}
144
145func (ec *executionContext) fieldContext_AddCommentTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
146 fc = &graphql.FieldContext{
147 Object: "AddCommentTimelineItem",
148 Field: field,
149 IsMethod: true,
150 IsResolver: true,
151 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
152 switch field.Name {
153 case "id":
154 return ec.fieldContext_Identity_id(ctx, field)
155 case "humanId":
156 return ec.fieldContext_Identity_humanId(ctx, field)
157 case "name":
158 return ec.fieldContext_Identity_name(ctx, field)
159 case "email":
160 return ec.fieldContext_Identity_email(ctx, field)
161 case "login":
162 return ec.fieldContext_Identity_login(ctx, field)
163 case "displayName":
164 return ec.fieldContext_Identity_displayName(ctx, field)
165 case "avatarUrl":
166 return ec.fieldContext_Identity_avatarUrl(ctx, field)
167 case "isProtected":
168 return ec.fieldContext_Identity_isProtected(ctx, field)
169 }
170 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
171 },
172 }
173 return fc, nil
174}
175
176func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
177 fc, err := ec.fieldContext_AddCommentTimelineItem_message(ctx, field)
178 if err != nil {
179 return graphql.Null
180 }
181 ctx = graphql.WithFieldContext(ctx, fc)
182 defer func() {
183 if r := recover(); r != nil {
184 ec.Error(ctx, ec.Recover(ctx, r))
185 ret = graphql.Null
186 }
187 }()
188 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
189 ctx = rctx // use context from middleware stack in children
190 return obj.Message, nil
191 })
192 if err != nil {
193 ec.Error(ctx, err)
194 return graphql.Null
195 }
196 if resTmp == nil {
197 if !graphql.HasFieldError(ctx, fc) {
198 ec.Errorf(ctx, "must not be null")
199 }
200 return graphql.Null
201 }
202 res := resTmp.(string)
203 fc.Result = res
204 return ec.marshalNString2string(ctx, field.Selections, res)
205}
206
207func (ec *executionContext) fieldContext_AddCommentTimelineItem_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
208 fc = &graphql.FieldContext{
209 Object: "AddCommentTimelineItem",
210 Field: field,
211 IsMethod: false,
212 IsResolver: false,
213 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
214 return nil, errors.New("field of type String does not have child fields")
215 },
216 }
217 return fc, nil
218}
219
220func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
221 fc, err := ec.fieldContext_AddCommentTimelineItem_messageIsEmpty(ctx, field)
222 if err != nil {
223 return graphql.Null
224 }
225 ctx = graphql.WithFieldContext(ctx, fc)
226 defer func() {
227 if r := recover(); r != nil {
228 ec.Error(ctx, ec.Recover(ctx, r))
229 ret = graphql.Null
230 }
231 }()
232 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
233 ctx = rctx // use context from middleware stack in children
234 return obj.MessageIsEmpty(), nil
235 })
236 if err != nil {
237 ec.Error(ctx, err)
238 return graphql.Null
239 }
240 if resTmp == nil {
241 if !graphql.HasFieldError(ctx, fc) {
242 ec.Errorf(ctx, "must not be null")
243 }
244 return graphql.Null
245 }
246 res := resTmp.(bool)
247 fc.Result = res
248 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
249}
250
251func (ec *executionContext) fieldContext_AddCommentTimelineItem_messageIsEmpty(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
252 fc = &graphql.FieldContext{
253 Object: "AddCommentTimelineItem",
254 Field: field,
255 IsMethod: true,
256 IsResolver: false,
257 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
258 return nil, errors.New("field of type Boolean does not have child fields")
259 },
260 }
261 return fc, nil
262}
263
264func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
265 fc, err := ec.fieldContext_AddCommentTimelineItem_files(ctx, field)
266 if err != nil {
267 return graphql.Null
268 }
269 ctx = graphql.WithFieldContext(ctx, fc)
270 defer func() {
271 if r := recover(); r != nil {
272 ec.Error(ctx, ec.Recover(ctx, r))
273 ret = graphql.Null
274 }
275 }()
276 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
277 ctx = rctx // use context from middleware stack in children
278 return obj.Files, nil
279 })
280 if err != nil {
281 ec.Error(ctx, err)
282 return graphql.Null
283 }
284 if resTmp == nil {
285 if !graphql.HasFieldError(ctx, fc) {
286 ec.Errorf(ctx, "must not be null")
287 }
288 return graphql.Null
289 }
290 res := resTmp.([]repository.Hash)
291 fc.Result = res
292 return ec.marshalNHash2ágithubácomágitábugágitábugárepositoryáHashá(ctx, field.Selections, res)
293}
294
295func (ec *executionContext) fieldContext_AddCommentTimelineItem_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
296 fc = &graphql.FieldContext{
297 Object: "AddCommentTimelineItem",
298 Field: field,
299 IsMethod: false,
300 IsResolver: false,
301 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
302 return nil, errors.New("field of type Hash does not have child fields")
303 },
304 }
305 return fc, nil
306}
307
308func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
309 fc, err := ec.fieldContext_AddCommentTimelineItem_createdAt(ctx, field)
310 if err != nil {
311 return graphql.Null
312 }
313 ctx = graphql.WithFieldContext(ctx, fc)
314 defer func() {
315 if r := recover(); r != nil {
316 ec.Error(ctx, ec.Recover(ctx, r))
317 ret = graphql.Null
318 }
319 }()
320 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
321 ctx = rctx // use context from middleware stack in children
322 return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
323 })
324 if err != nil {
325 ec.Error(ctx, err)
326 return graphql.Null
327 }
328 if resTmp == nil {
329 if !graphql.HasFieldError(ctx, fc) {
330 ec.Errorf(ctx, "must not be null")
331 }
332 return graphql.Null
333 }
334 res := resTmp.(*time.Time)
335 fc.Result = res
336 return ec.marshalNTime2átimeáTime(ctx, field.Selections, res)
337}
338
339func (ec *executionContext) fieldContext_AddCommentTimelineItem_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
340 fc = &graphql.FieldContext{
341 Object: "AddCommentTimelineItem",
342 Field: field,
343 IsMethod: true,
344 IsResolver: true,
345 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
346 return nil, errors.New("field of type Time does not have child fields")
347 },
348 }
349 return fc, nil
350}
351
352func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
353 fc, err := ec.fieldContext_AddCommentTimelineItem_lastEdit(ctx, field)
354 if err != nil {
355 return graphql.Null
356 }
357 ctx = graphql.WithFieldContext(ctx, fc)
358 defer func() {
359 if r := recover(); r != nil {
360 ec.Error(ctx, ec.Recover(ctx, r))
361 ret = graphql.Null
362 }
363 }()
364 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
365 ctx = rctx // use context from middleware stack in children
366 return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
367 })
368 if err != nil {
369 ec.Error(ctx, err)
370 return graphql.Null
371 }
372 if resTmp == nil {
373 if !graphql.HasFieldError(ctx, fc) {
374 ec.Errorf(ctx, "must not be null")
375 }
376 return graphql.Null
377 }
378 res := resTmp.(*time.Time)
379 fc.Result = res
380 return ec.marshalNTime2átimeáTime(ctx, field.Selections, res)
381}
382
383func (ec *executionContext) fieldContext_AddCommentTimelineItem_lastEdit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
384 fc = &graphql.FieldContext{
385 Object: "AddCommentTimelineItem",
386 Field: field,
387 IsMethod: true,
388 IsResolver: true,
389 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
390 return nil, errors.New("field of type Time does not have child fields")
391 },
392 }
393 return fc, nil
394}
395
396func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
397 fc, err := ec.fieldContext_AddCommentTimelineItem_edited(ctx, field)
398 if err != nil {
399 return graphql.Null
400 }
401 ctx = graphql.WithFieldContext(ctx, fc)
402 defer func() {
403 if r := recover(); r != nil {
404 ec.Error(ctx, ec.Recover(ctx, r))
405 ret = graphql.Null
406 }
407 }()
408 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
409 ctx = rctx // use context from middleware stack in children
410 return obj.Edited(), nil
411 })
412 if err != nil {
413 ec.Error(ctx, err)
414 return graphql.Null
415 }
416 if resTmp == nil {
417 if !graphql.HasFieldError(ctx, fc) {
418 ec.Errorf(ctx, "must not be null")
419 }
420 return graphql.Null
421 }
422 res := resTmp.(bool)
423 fc.Result = res
424 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
425}
426
427func (ec *executionContext) fieldContext_AddCommentTimelineItem_edited(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
428 fc = &graphql.FieldContext{
429 Object: "AddCommentTimelineItem",
430 Field: field,
431 IsMethod: true,
432 IsResolver: false,
433 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
434 return nil, errors.New("field of type Boolean does not have child fields")
435 },
436 }
437 return fc, nil
438}
439
440func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
441 fc, err := ec.fieldContext_AddCommentTimelineItem_history(ctx, field)
442 if err != nil {
443 return graphql.Null
444 }
445 ctx = graphql.WithFieldContext(ctx, fc)
446 defer func() {
447 if r := recover(); r != nil {
448 ec.Error(ctx, ec.Recover(ctx, r))
449 ret = graphql.Null
450 }
451 }()
452 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
453 ctx = rctx // use context from middleware stack in children
454 return obj.History, nil
455 })
456 if err != nil {
457 ec.Error(ctx, err)
458 return graphql.Null
459 }
460 if resTmp == nil {
461 if !graphql.HasFieldError(ctx, fc) {
462 ec.Errorf(ctx, "must not be null")
463 }
464 return graphql.Null
465 }
466 res := resTmp.([]bug.CommentHistoryStep)
467 fc.Result = res
468 return ec.marshalNCommentHistoryStep2ágithubácomágitábugágitábugáentitiesábugáCommentHistoryStepá(ctx, field.Selections, res)
469}
470
471func (ec *executionContext) fieldContext_AddCommentTimelineItem_history(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
472 fc = &graphql.FieldContext{
473 Object: "AddCommentTimelineItem",
474 Field: field,
475 IsMethod: false,
476 IsResolver: false,
477 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
478 switch field.Name {
479 case "message":
480 return ec.fieldContext_CommentHistoryStep_message(ctx, field)
481 case "date":
482 return ec.fieldContext_CommentHistoryStep_date(ctx, field)
483 }
484 return nil, fmt.Errorf("no field named %q was found under type CommentHistoryStep", field.Name)
485 },
486 }
487 return fc, nil
488}
489
490func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
491 fc, err := ec.fieldContext_CommentHistoryStep_message(ctx, field)
492 if err != nil {
493 return graphql.Null
494 }
495 ctx = graphql.WithFieldContext(ctx, fc)
496 defer func() {
497 if r := recover(); r != nil {
498 ec.Error(ctx, ec.Recover(ctx, r))
499 ret = graphql.Null
500 }
501 }()
502 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
503 ctx = rctx // use context from middleware stack in children
504 return obj.Message, nil
505 })
506 if err != nil {
507 ec.Error(ctx, err)
508 return graphql.Null
509 }
510 if resTmp == nil {
511 if !graphql.HasFieldError(ctx, fc) {
512 ec.Errorf(ctx, "must not be null")
513 }
514 return graphql.Null
515 }
516 res := resTmp.(string)
517 fc.Result = res
518 return ec.marshalNString2string(ctx, field.Selections, res)
519}
520
521func (ec *executionContext) fieldContext_CommentHistoryStep_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
522 fc = &graphql.FieldContext{
523 Object: "CommentHistoryStep",
524 Field: field,
525 IsMethod: false,
526 IsResolver: false,
527 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
528 return nil, errors.New("field of type String does not have child fields")
529 },
530 }
531 return fc, nil
532}
533
534func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
535 fc, err := ec.fieldContext_CommentHistoryStep_date(ctx, field)
536 if err != nil {
537 return graphql.Null
538 }
539 ctx = graphql.WithFieldContext(ctx, fc)
540 defer func() {
541 if r := recover(); r != nil {
542 ec.Error(ctx, ec.Recover(ctx, r))
543 ret = graphql.Null
544 }
545 }()
546 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
547 ctx = rctx // use context from middleware stack in children
548 return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
549 })
550 if err != nil {
551 ec.Error(ctx, err)
552 return graphql.Null
553 }
554 if resTmp == nil {
555 if !graphql.HasFieldError(ctx, fc) {
556 ec.Errorf(ctx, "must not be null")
557 }
558 return graphql.Null
559 }
560 res := resTmp.(*time.Time)
561 fc.Result = res
562 return ec.marshalNTime2átimeáTime(ctx, field.Selections, res)
563}
564
565func (ec *executionContext) fieldContext_CommentHistoryStep_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
566 fc = &graphql.FieldContext{
567 Object: "CommentHistoryStep",
568 Field: field,
569 IsMethod: true,
570 IsResolver: true,
571 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
572 return nil, errors.New("field of type Time does not have child fields")
573 },
574 }
575 return fc, nil
576}
577
578func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
579 fc, err := ec.fieldContext_CreateTimelineItem_id(ctx, field)
580 if err != nil {
581 return graphql.Null
582 }
583 ctx = graphql.WithFieldContext(ctx, fc)
584 defer func() {
585 if r := recover(); r != nil {
586 ec.Error(ctx, ec.Recover(ctx, r))
587 ret = graphql.Null
588 }
589 }()
590 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
591 ctx = rctx // use context from middleware stack in children
592 return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
593 })
594 if err != nil {
595 ec.Error(ctx, err)
596 return graphql.Null
597 }
598 if resTmp == nil {
599 if !graphql.HasFieldError(ctx, fc) {
600 ec.Errorf(ctx, "must not be null")
601 }
602 return graphql.Null
603 }
604 res := resTmp.(entity.CombinedId)
605 fc.Result = res
606 return ec.marshalNCombinedId2githubácomágitábugágitábugáentityáCombinedId(ctx, field.Selections, res)
607}
608
609func (ec *executionContext) fieldContext_CreateTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
610 fc = &graphql.FieldContext{
611 Object: "CreateTimelineItem",
612 Field: field,
613 IsMethod: true,
614 IsResolver: true,
615 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
616 return nil, errors.New("field of type CombinedId does not have child fields")
617 },
618 }
619 return fc, nil
620}
621
622func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
623 fc, err := ec.fieldContext_CreateTimelineItem_author(ctx, field)
624 if err != nil {
625 return graphql.Null
626 }
627 ctx = graphql.WithFieldContext(ctx, fc)
628 defer func() {
629 if r := recover(); r != nil {
630 ec.Error(ctx, ec.Recover(ctx, r))
631 ret = graphql.Null
632 }
633 }()
634 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
635 ctx = rctx // use context from middleware stack in children
636 return ec.resolvers.CreateTimelineItem().Author(rctx, obj)
637 })
638 if err != nil {
639 ec.Error(ctx, err)
640 return graphql.Null
641 }
642 if resTmp == nil {
643 if !graphql.HasFieldError(ctx, fc) {
644 ec.Errorf(ctx, "must not be null")
645 }
646 return graphql.Null
647 }
648 res := resTmp.(models.IdentityWrapper)
649 fc.Result = res
650 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
651}
652
653func (ec *executionContext) fieldContext_CreateTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
654 fc = &graphql.FieldContext{
655 Object: "CreateTimelineItem",
656 Field: field,
657 IsMethod: true,
658 IsResolver: true,
659 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
660 switch field.Name {
661 case "id":
662 return ec.fieldContext_Identity_id(ctx, field)
663 case "humanId":
664 return ec.fieldContext_Identity_humanId(ctx, field)
665 case "name":
666 return ec.fieldContext_Identity_name(ctx, field)
667 case "email":
668 return ec.fieldContext_Identity_email(ctx, field)
669 case "login":
670 return ec.fieldContext_Identity_login(ctx, field)
671 case "displayName":
672 return ec.fieldContext_Identity_displayName(ctx, field)
673 case "avatarUrl":
674 return ec.fieldContext_Identity_avatarUrl(ctx, field)
675 case "isProtected":
676 return ec.fieldContext_Identity_isProtected(ctx, field)
677 }
678 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
679 },
680 }
681 return fc, nil
682}
683
684func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
685 fc, err := ec.fieldContext_CreateTimelineItem_message(ctx, field)
686 if err != nil {
687 return graphql.Null
688 }
689 ctx = graphql.WithFieldContext(ctx, fc)
690 defer func() {
691 if r := recover(); r != nil {
692 ec.Error(ctx, ec.Recover(ctx, r))
693 ret = graphql.Null
694 }
695 }()
696 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
697 ctx = rctx // use context from middleware stack in children
698 return obj.Message, nil
699 })
700 if err != nil {
701 ec.Error(ctx, err)
702 return graphql.Null
703 }
704 if resTmp == nil {
705 if !graphql.HasFieldError(ctx, fc) {
706 ec.Errorf(ctx, "must not be null")
707 }
708 return graphql.Null
709 }
710 res := resTmp.(string)
711 fc.Result = res
712 return ec.marshalNString2string(ctx, field.Selections, res)
713}
714
715func (ec *executionContext) fieldContext_CreateTimelineItem_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
716 fc = &graphql.FieldContext{
717 Object: "CreateTimelineItem",
718 Field: field,
719 IsMethod: false,
720 IsResolver: false,
721 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
722 return nil, errors.New("field of type String does not have child fields")
723 },
724 }
725 return fc, nil
726}
727
728func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
729 fc, err := ec.fieldContext_CreateTimelineItem_messageIsEmpty(ctx, field)
730 if err != nil {
731 return graphql.Null
732 }
733 ctx = graphql.WithFieldContext(ctx, fc)
734 defer func() {
735 if r := recover(); r != nil {
736 ec.Error(ctx, ec.Recover(ctx, r))
737 ret = graphql.Null
738 }
739 }()
740 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
741 ctx = rctx // use context from middleware stack in children
742 return obj.MessageIsEmpty(), nil
743 })
744 if err != nil {
745 ec.Error(ctx, err)
746 return graphql.Null
747 }
748 if resTmp == nil {
749 if !graphql.HasFieldError(ctx, fc) {
750 ec.Errorf(ctx, "must not be null")
751 }
752 return graphql.Null
753 }
754 res := resTmp.(bool)
755 fc.Result = res
756 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
757}
758
759func (ec *executionContext) fieldContext_CreateTimelineItem_messageIsEmpty(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
760 fc = &graphql.FieldContext{
761 Object: "CreateTimelineItem",
762 Field: field,
763 IsMethod: true,
764 IsResolver: false,
765 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
766 return nil, errors.New("field of type Boolean does not have child fields")
767 },
768 }
769 return fc, nil
770}
771
772func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
773 fc, err := ec.fieldContext_CreateTimelineItem_files(ctx, field)
774 if err != nil {
775 return graphql.Null
776 }
777 ctx = graphql.WithFieldContext(ctx, fc)
778 defer func() {
779 if r := recover(); r != nil {
780 ec.Error(ctx, ec.Recover(ctx, r))
781 ret = graphql.Null
782 }
783 }()
784 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
785 ctx = rctx // use context from middleware stack in children
786 return obj.Files, nil
787 })
788 if err != nil {
789 ec.Error(ctx, err)
790 return graphql.Null
791 }
792 if resTmp == nil {
793 if !graphql.HasFieldError(ctx, fc) {
794 ec.Errorf(ctx, "must not be null")
795 }
796 return graphql.Null
797 }
798 res := resTmp.([]repository.Hash)
799 fc.Result = res
800 return ec.marshalNHash2ágithubácomágitábugágitábugárepositoryáHashá(ctx, field.Selections, res)
801}
802
803func (ec *executionContext) fieldContext_CreateTimelineItem_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
804 fc = &graphql.FieldContext{
805 Object: "CreateTimelineItem",
806 Field: field,
807 IsMethod: false,
808 IsResolver: false,
809 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
810 return nil, errors.New("field of type Hash does not have child fields")
811 },
812 }
813 return fc, nil
814}
815
816func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
817 fc, err := ec.fieldContext_CreateTimelineItem_createdAt(ctx, field)
818 if err != nil {
819 return graphql.Null
820 }
821 ctx = graphql.WithFieldContext(ctx, fc)
822 defer func() {
823 if r := recover(); r != nil {
824 ec.Error(ctx, ec.Recover(ctx, r))
825 ret = graphql.Null
826 }
827 }()
828 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
829 ctx = rctx // use context from middleware stack in children
830 return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
831 })
832 if err != nil {
833 ec.Error(ctx, err)
834 return graphql.Null
835 }
836 if resTmp == nil {
837 if !graphql.HasFieldError(ctx, fc) {
838 ec.Errorf(ctx, "must not be null")
839 }
840 return graphql.Null
841 }
842 res := resTmp.(*time.Time)
843 fc.Result = res
844 return ec.marshalNTime2átimeáTime(ctx, field.Selections, res)
845}
846
847func (ec *executionContext) fieldContext_CreateTimelineItem_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
848 fc = &graphql.FieldContext{
849 Object: "CreateTimelineItem",
850 Field: field,
851 IsMethod: true,
852 IsResolver: true,
853 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
854 return nil, errors.New("field of type Time does not have child fields")
855 },
856 }
857 return fc, nil
858}
859
860func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
861 fc, err := ec.fieldContext_CreateTimelineItem_lastEdit(ctx, field)
862 if err != nil {
863 return graphql.Null
864 }
865 ctx = graphql.WithFieldContext(ctx, fc)
866 defer func() {
867 if r := recover(); r != nil {
868 ec.Error(ctx, ec.Recover(ctx, r))
869 ret = graphql.Null
870 }
871 }()
872 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
873 ctx = rctx // use context from middleware stack in children
874 return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
875 })
876 if err != nil {
877 ec.Error(ctx, err)
878 return graphql.Null
879 }
880 if resTmp == nil {
881 if !graphql.HasFieldError(ctx, fc) {
882 ec.Errorf(ctx, "must not be null")
883 }
884 return graphql.Null
885 }
886 res := resTmp.(*time.Time)
887 fc.Result = res
888 return ec.marshalNTime2átimeáTime(ctx, field.Selections, res)
889}
890
891func (ec *executionContext) fieldContext_CreateTimelineItem_lastEdit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
892 fc = &graphql.FieldContext{
893 Object: "CreateTimelineItem",
894 Field: field,
895 IsMethod: true,
896 IsResolver: true,
897 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
898 return nil, errors.New("field of type Time does not have child fields")
899 },
900 }
901 return fc, nil
902}
903
904func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
905 fc, err := ec.fieldContext_CreateTimelineItem_edited(ctx, field)
906 if err != nil {
907 return graphql.Null
908 }
909 ctx = graphql.WithFieldContext(ctx, fc)
910 defer func() {
911 if r := recover(); r != nil {
912 ec.Error(ctx, ec.Recover(ctx, r))
913 ret = graphql.Null
914 }
915 }()
916 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
917 ctx = rctx // use context from middleware stack in children
918 return obj.Edited(), nil
919 })
920 if err != nil {
921 ec.Error(ctx, err)
922 return graphql.Null
923 }
924 if resTmp == nil {
925 if !graphql.HasFieldError(ctx, fc) {
926 ec.Errorf(ctx, "must not be null")
927 }
928 return graphql.Null
929 }
930 res := resTmp.(bool)
931 fc.Result = res
932 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
933}
934
935func (ec *executionContext) fieldContext_CreateTimelineItem_edited(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
936 fc = &graphql.FieldContext{
937 Object: "CreateTimelineItem",
938 Field: field,
939 IsMethod: true,
940 IsResolver: false,
941 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
942 return nil, errors.New("field of type Boolean does not have child fields")
943 },
944 }
945 return fc, nil
946}
947
948func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
949 fc, err := ec.fieldContext_CreateTimelineItem_history(ctx, field)
950 if err != nil {
951 return graphql.Null
952 }
953 ctx = graphql.WithFieldContext(ctx, fc)
954 defer func() {
955 if r := recover(); r != nil {
956 ec.Error(ctx, ec.Recover(ctx, r))
957 ret = graphql.Null
958 }
959 }()
960 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
961 ctx = rctx // use context from middleware stack in children
962 return obj.History, nil
963 })
964 if err != nil {
965 ec.Error(ctx, err)
966 return graphql.Null
967 }
968 if resTmp == nil {
969 if !graphql.HasFieldError(ctx, fc) {
970 ec.Errorf(ctx, "must not be null")
971 }
972 return graphql.Null
973 }
974 res := resTmp.([]bug.CommentHistoryStep)
975 fc.Result = res
976 return ec.marshalNCommentHistoryStep2ágithubácomágitábugágitábugáentitiesábugáCommentHistoryStepá(ctx, field.Selections, res)
977}
978
979func (ec *executionContext) fieldContext_CreateTimelineItem_history(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
980 fc = &graphql.FieldContext{
981 Object: "CreateTimelineItem",
982 Field: field,
983 IsMethod: false,
984 IsResolver: false,
985 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
986 switch field.Name {
987 case "message":
988 return ec.fieldContext_CommentHistoryStep_message(ctx, field)
989 case "date":
990 return ec.fieldContext_CommentHistoryStep_date(ctx, field)
991 }
992 return nil, fmt.Errorf("no field named %q was found under type CommentHistoryStep", field.Name)
993 },
994 }
995 return fc, nil
996}
997
998func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
999 fc, err := ec.fieldContext_LabelChangeTimelineItem_id(ctx, field)
1000 if err != nil {
1001 return graphql.Null
1002 }
1003 ctx = graphql.WithFieldContext(ctx, fc)
1004 defer func() {
1005 if r := recover(); r != nil {
1006 ec.Error(ctx, ec.Recover(ctx, r))
1007 ret = graphql.Null
1008 }
1009 }()
1010 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1011 ctx = rctx // use context from middleware stack in children
1012 return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
1013 })
1014 if err != nil {
1015 ec.Error(ctx, err)
1016 return graphql.Null
1017 }
1018 if resTmp == nil {
1019 if !graphql.HasFieldError(ctx, fc) {
1020 ec.Errorf(ctx, "must not be null")
1021 }
1022 return graphql.Null
1023 }
1024 res := resTmp.(entity.CombinedId)
1025 fc.Result = res
1026 return ec.marshalNCombinedId2githubácomágitábugágitábugáentityáCombinedId(ctx, field.Selections, res)
1027}
1028
1029func (ec *executionContext) fieldContext_LabelChangeTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1030 fc = &graphql.FieldContext{
1031 Object: "LabelChangeTimelineItem",
1032 Field: field,
1033 IsMethod: true,
1034 IsResolver: true,
1035 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1036 return nil, errors.New("field of type CombinedId does not have child fields")
1037 },
1038 }
1039 return fc, nil
1040}
1041
1042func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
1043 fc, err := ec.fieldContext_LabelChangeTimelineItem_author(ctx, field)
1044 if err != nil {
1045 return graphql.Null
1046 }
1047 ctx = graphql.WithFieldContext(ctx, fc)
1048 defer func() {
1049 if r := recover(); r != nil {
1050 ec.Error(ctx, ec.Recover(ctx, r))
1051 ret = graphql.Null
1052 }
1053 }()
1054 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1055 ctx = rctx // use context from middleware stack in children
1056 return ec.resolvers.LabelChangeTimelineItem().Author(rctx, obj)
1057 })
1058 if err != nil {
1059 ec.Error(ctx, err)
1060 return graphql.Null
1061 }
1062 if resTmp == nil {
1063 if !graphql.HasFieldError(ctx, fc) {
1064 ec.Errorf(ctx, "must not be null")
1065 }
1066 return graphql.Null
1067 }
1068 res := resTmp.(models.IdentityWrapper)
1069 fc.Result = res
1070 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
1071}
1072
1073func (ec *executionContext) fieldContext_LabelChangeTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1074 fc = &graphql.FieldContext{
1075 Object: "LabelChangeTimelineItem",
1076 Field: field,
1077 IsMethod: true,
1078 IsResolver: true,
1079 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1080 switch field.Name {
1081 case "id":
1082 return ec.fieldContext_Identity_id(ctx, field)
1083 case "humanId":
1084 return ec.fieldContext_Identity_humanId(ctx, field)
1085 case "name":
1086 return ec.fieldContext_Identity_name(ctx, field)
1087 case "email":
1088 return ec.fieldContext_Identity_email(ctx, field)
1089 case "login":
1090 return ec.fieldContext_Identity_login(ctx, field)
1091 case "displayName":
1092 return ec.fieldContext_Identity_displayName(ctx, field)
1093 case "avatarUrl":
1094 return ec.fieldContext_Identity_avatarUrl(ctx, field)
1095 case "isProtected":
1096 return ec.fieldContext_Identity_isProtected(ctx, field)
1097 }
1098 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
1099 },
1100 }
1101 return fc, nil
1102}
1103
1104func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
1105 fc, err := ec.fieldContext_LabelChangeTimelineItem_date(ctx, field)
1106 if err != nil {
1107 return graphql.Null
1108 }
1109 ctx = graphql.WithFieldContext(ctx, fc)
1110 defer func() {
1111 if r := recover(); r != nil {
1112 ec.Error(ctx, ec.Recover(ctx, r))
1113 ret = graphql.Null
1114 }
1115 }()
1116 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1117 ctx = rctx // use context from middleware stack in children
1118 return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
1119 })
1120 if err != nil {
1121 ec.Error(ctx, err)
1122 return graphql.Null
1123 }
1124 if resTmp == nil {
1125 if !graphql.HasFieldError(ctx, fc) {
1126 ec.Errorf(ctx, "must not be null")
1127 }
1128 return graphql.Null
1129 }
1130 res := resTmp.(*time.Time)
1131 fc.Result = res
1132 return ec.marshalNTime2átimeáTime(ctx, field.Selections, res)
1133}
1134
1135func (ec *executionContext) fieldContext_LabelChangeTimelineItem_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1136 fc = &graphql.FieldContext{
1137 Object: "LabelChangeTimelineItem",
1138 Field: field,
1139 IsMethod: true,
1140 IsResolver: true,
1141 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1142 return nil, errors.New("field of type Time does not have child fields")
1143 },
1144 }
1145 return fc, nil
1146}
1147
1148func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
1149 fc, err := ec.fieldContext_LabelChangeTimelineItem_added(ctx, field)
1150 if err != nil {
1151 return graphql.Null
1152 }
1153 ctx = graphql.WithFieldContext(ctx, fc)
1154 defer func() {
1155 if r := recover(); r != nil {
1156 ec.Error(ctx, ec.Recover(ctx, r))
1157 ret = graphql.Null
1158 }
1159 }()
1160 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1161 ctx = rctx // use context from middleware stack in children
1162 return obj.Added, nil
1163 })
1164 if err != nil {
1165 ec.Error(ctx, err)
1166 return graphql.Null
1167 }
1168 if resTmp == nil {
1169 if !graphql.HasFieldError(ctx, fc) {
1170 ec.Errorf(ctx, "must not be null")
1171 }
1172 return graphql.Null
1173 }
1174 res := resTmp.([]common.Label)
1175 fc.Result = res
1176 return ec.marshalNLabel2ágithubácomágitábugágitábugáentitiesácommonáLabelá(ctx, field.Selections, res)
1177}
1178
1179func (ec *executionContext) fieldContext_LabelChangeTimelineItem_added(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1180 fc = &graphql.FieldContext{
1181 Object: "LabelChangeTimelineItem",
1182 Field: field,
1183 IsMethod: false,
1184 IsResolver: false,
1185 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1186 switch field.Name {
1187 case "name":
1188 return ec.fieldContext_Label_name(ctx, field)
1189 case "color":
1190 return ec.fieldContext_Label_color(ctx, field)
1191 }
1192 return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
1193 },
1194 }
1195 return fc, nil
1196}
1197
1198func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
1199 fc, err := ec.fieldContext_LabelChangeTimelineItem_removed(ctx, field)
1200 if err != nil {
1201 return graphql.Null
1202 }
1203 ctx = graphql.WithFieldContext(ctx, fc)
1204 defer func() {
1205 if r := recover(); r != nil {
1206 ec.Error(ctx, ec.Recover(ctx, r))
1207 ret = graphql.Null
1208 }
1209 }()
1210 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1211 ctx = rctx // use context from middleware stack in children
1212 return obj.Removed, nil
1213 })
1214 if err != nil {
1215 ec.Error(ctx, err)
1216 return graphql.Null
1217 }
1218 if resTmp == nil {
1219 if !graphql.HasFieldError(ctx, fc) {
1220 ec.Errorf(ctx, "must not be null")
1221 }
1222 return graphql.Null
1223 }
1224 res := resTmp.([]common.Label)
1225 fc.Result = res
1226 return ec.marshalNLabel2ágithubácomágitábugágitábugáentitiesácommonáLabelá(ctx, field.Selections, res)
1227}
1228
1229func (ec *executionContext) fieldContext_LabelChangeTimelineItem_removed(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1230 fc = &graphql.FieldContext{
1231 Object: "LabelChangeTimelineItem",
1232 Field: field,
1233 IsMethod: false,
1234 IsResolver: false,
1235 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1236 switch field.Name {
1237 case "name":
1238 return ec.fieldContext_Label_name(ctx, field)
1239 case "color":
1240 return ec.fieldContext_Label_color(ctx, field)
1241 }
1242 return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
1243 },
1244 }
1245 return fc, nil
1246}
1247
1248func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
1249 fc, err := ec.fieldContext_SetStatusTimelineItem_id(ctx, field)
1250 if err != nil {
1251 return graphql.Null
1252 }
1253 ctx = graphql.WithFieldContext(ctx, fc)
1254 defer func() {
1255 if r := recover(); r != nil {
1256 ec.Error(ctx, ec.Recover(ctx, r))
1257 ret = graphql.Null
1258 }
1259 }()
1260 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1261 ctx = rctx // use context from middleware stack in children
1262 return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
1263 })
1264 if err != nil {
1265 ec.Error(ctx, err)
1266 return graphql.Null
1267 }
1268 if resTmp == nil {
1269 if !graphql.HasFieldError(ctx, fc) {
1270 ec.Errorf(ctx, "must not be null")
1271 }
1272 return graphql.Null
1273 }
1274 res := resTmp.(entity.CombinedId)
1275 fc.Result = res
1276 return ec.marshalNCombinedId2githubácomágitábugágitábugáentityáCombinedId(ctx, field.Selections, res)
1277}
1278
1279func (ec *executionContext) fieldContext_SetStatusTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1280 fc = &graphql.FieldContext{
1281 Object: "SetStatusTimelineItem",
1282 Field: field,
1283 IsMethod: true,
1284 IsResolver: true,
1285 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1286 return nil, errors.New("field of type CombinedId does not have child fields")
1287 },
1288 }
1289 return fc, nil
1290}
1291
1292func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
1293 fc, err := ec.fieldContext_SetStatusTimelineItem_author(ctx, field)
1294 if err != nil {
1295 return graphql.Null
1296 }
1297 ctx = graphql.WithFieldContext(ctx, fc)
1298 defer func() {
1299 if r := recover(); r != nil {
1300 ec.Error(ctx, ec.Recover(ctx, r))
1301 ret = graphql.Null
1302 }
1303 }()
1304 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1305 ctx = rctx // use context from middleware stack in children
1306 return ec.resolvers.SetStatusTimelineItem().Author(rctx, obj)
1307 })
1308 if err != nil {
1309 ec.Error(ctx, err)
1310 return graphql.Null
1311 }
1312 if resTmp == nil {
1313 if !graphql.HasFieldError(ctx, fc) {
1314 ec.Errorf(ctx, "must not be null")
1315 }
1316 return graphql.Null
1317 }
1318 res := resTmp.(models.IdentityWrapper)
1319 fc.Result = res
1320 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
1321}
1322
1323func (ec *executionContext) fieldContext_SetStatusTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1324 fc = &graphql.FieldContext{
1325 Object: "SetStatusTimelineItem",
1326 Field: field,
1327 IsMethod: true,
1328 IsResolver: true,
1329 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1330 switch field.Name {
1331 case "id":
1332 return ec.fieldContext_Identity_id(ctx, field)
1333 case "humanId":
1334 return ec.fieldContext_Identity_humanId(ctx, field)
1335 case "name":
1336 return ec.fieldContext_Identity_name(ctx, field)
1337 case "email":
1338 return ec.fieldContext_Identity_email(ctx, field)
1339 case "login":
1340 return ec.fieldContext_Identity_login(ctx, field)
1341 case "displayName":
1342 return ec.fieldContext_Identity_displayName(ctx, field)
1343 case "avatarUrl":
1344 return ec.fieldContext_Identity_avatarUrl(ctx, field)
1345 case "isProtected":
1346 return ec.fieldContext_Identity_isProtected(ctx, field)
1347 }
1348 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
1349 },
1350 }
1351 return fc, nil
1352}
1353
1354func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
1355 fc, err := ec.fieldContext_SetStatusTimelineItem_date(ctx, field)
1356 if err != nil {
1357 return graphql.Null
1358 }
1359 ctx = graphql.WithFieldContext(ctx, fc)
1360 defer func() {
1361 if r := recover(); r != nil {
1362 ec.Error(ctx, ec.Recover(ctx, r))
1363 ret = graphql.Null
1364 }
1365 }()
1366 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1367 ctx = rctx // use context from middleware stack in children
1368 return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
1369 })
1370 if err != nil {
1371 ec.Error(ctx, err)
1372 return graphql.Null
1373 }
1374 if resTmp == nil {
1375 if !graphql.HasFieldError(ctx, fc) {
1376 ec.Errorf(ctx, "must not be null")
1377 }
1378 return graphql.Null
1379 }
1380 res := resTmp.(*time.Time)
1381 fc.Result = res
1382 return ec.marshalNTime2átimeáTime(ctx, field.Selections, res)
1383}
1384
1385func (ec *executionContext) fieldContext_SetStatusTimelineItem_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1386 fc = &graphql.FieldContext{
1387 Object: "SetStatusTimelineItem",
1388 Field: field,
1389 IsMethod: true,
1390 IsResolver: true,
1391 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1392 return nil, errors.New("field of type Time does not have child fields")
1393 },
1394 }
1395 return fc, nil
1396}
1397
1398func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
1399 fc, err := ec.fieldContext_SetStatusTimelineItem_status(ctx, field)
1400 if err != nil {
1401 return graphql.Null
1402 }
1403 ctx = graphql.WithFieldContext(ctx, fc)
1404 defer func() {
1405 if r := recover(); r != nil {
1406 ec.Error(ctx, ec.Recover(ctx, r))
1407 ret = graphql.Null
1408 }
1409 }()
1410 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1411 ctx = rctx // use context from middleware stack in children
1412 return obj.Status, nil
1413 })
1414 if err != nil {
1415 ec.Error(ctx, err)
1416 return graphql.Null
1417 }
1418 if resTmp == nil {
1419 if !graphql.HasFieldError(ctx, fc) {
1420 ec.Errorf(ctx, "must not be null")
1421 }
1422 return graphql.Null
1423 }
1424 res := resTmp.(common.Status)
1425 fc.Result = res
1426 return ec.marshalNStatus2githubácomágitábugágitábugáentitiesácommonáStatus(ctx, field.Selections, res)
1427}
1428
1429func (ec *executionContext) fieldContext_SetStatusTimelineItem_status(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1430 fc = &graphql.FieldContext{
1431 Object: "SetStatusTimelineItem",
1432 Field: field,
1433 IsMethod: false,
1434 IsResolver: false,
1435 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1436 return nil, errors.New("field of type Status does not have child fields")
1437 },
1438 }
1439 return fc, nil
1440}
1441
1442func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
1443 fc, err := ec.fieldContext_SetTitleTimelineItem_id(ctx, field)
1444 if err != nil {
1445 return graphql.Null
1446 }
1447 ctx = graphql.WithFieldContext(ctx, fc)
1448 defer func() {
1449 if r := recover(); r != nil {
1450 ec.Error(ctx, ec.Recover(ctx, r))
1451 ret = graphql.Null
1452 }
1453 }()
1454 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1455 ctx = rctx // use context from middleware stack in children
1456 return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
1457 })
1458 if err != nil {
1459 ec.Error(ctx, err)
1460 return graphql.Null
1461 }
1462 if resTmp == nil {
1463 if !graphql.HasFieldError(ctx, fc) {
1464 ec.Errorf(ctx, "must not be null")
1465 }
1466 return graphql.Null
1467 }
1468 res := resTmp.(entity.CombinedId)
1469 fc.Result = res
1470 return ec.marshalNCombinedId2githubácomágitábugágitábugáentityáCombinedId(ctx, field.Selections, res)
1471}
1472
1473func (ec *executionContext) fieldContext_SetTitleTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1474 fc = &graphql.FieldContext{
1475 Object: "SetTitleTimelineItem",
1476 Field: field,
1477 IsMethod: true,
1478 IsResolver: true,
1479 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1480 return nil, errors.New("field of type CombinedId does not have child fields")
1481 },
1482 }
1483 return fc, nil
1484}
1485
1486func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
1487 fc, err := ec.fieldContext_SetTitleTimelineItem_author(ctx, field)
1488 if err != nil {
1489 return graphql.Null
1490 }
1491 ctx = graphql.WithFieldContext(ctx, fc)
1492 defer func() {
1493 if r := recover(); r != nil {
1494 ec.Error(ctx, ec.Recover(ctx, r))
1495 ret = graphql.Null
1496 }
1497 }()
1498 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1499 ctx = rctx // use context from middleware stack in children
1500 return ec.resolvers.SetTitleTimelineItem().Author(rctx, obj)
1501 })
1502 if err != nil {
1503 ec.Error(ctx, err)
1504 return graphql.Null
1505 }
1506 if resTmp == nil {
1507 if !graphql.HasFieldError(ctx, fc) {
1508 ec.Errorf(ctx, "must not be null")
1509 }
1510 return graphql.Null
1511 }
1512 res := resTmp.(models.IdentityWrapper)
1513 fc.Result = res
1514 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
1515}
1516
1517func (ec *executionContext) fieldContext_SetTitleTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1518 fc = &graphql.FieldContext{
1519 Object: "SetTitleTimelineItem",
1520 Field: field,
1521 IsMethod: true,
1522 IsResolver: true,
1523 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1524 switch field.Name {
1525 case "id":
1526 return ec.fieldContext_Identity_id(ctx, field)
1527 case "humanId":
1528 return ec.fieldContext_Identity_humanId(ctx, field)
1529 case "name":
1530 return ec.fieldContext_Identity_name(ctx, field)
1531 case "email":
1532 return ec.fieldContext_Identity_email(ctx, field)
1533 case "login":
1534 return ec.fieldContext_Identity_login(ctx, field)
1535 case "displayName":
1536 return ec.fieldContext_Identity_displayName(ctx, field)
1537 case "avatarUrl":
1538 return ec.fieldContext_Identity_avatarUrl(ctx, field)
1539 case "isProtected":
1540 return ec.fieldContext_Identity_isProtected(ctx, field)
1541 }
1542 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
1543 },
1544 }
1545 return fc, nil
1546}
1547
1548func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
1549 fc, err := ec.fieldContext_SetTitleTimelineItem_date(ctx, field)
1550 if err != nil {
1551 return graphql.Null
1552 }
1553 ctx = graphql.WithFieldContext(ctx, fc)
1554 defer func() {
1555 if r := recover(); r != nil {
1556 ec.Error(ctx, ec.Recover(ctx, r))
1557 ret = graphql.Null
1558 }
1559 }()
1560 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1561 ctx = rctx // use context from middleware stack in children
1562 return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
1563 })
1564 if err != nil {
1565 ec.Error(ctx, err)
1566 return graphql.Null
1567 }
1568 if resTmp == nil {
1569 if !graphql.HasFieldError(ctx, fc) {
1570 ec.Errorf(ctx, "must not be null")
1571 }
1572 return graphql.Null
1573 }
1574 res := resTmp.(*time.Time)
1575 fc.Result = res
1576 return ec.marshalNTime2átimeáTime(ctx, field.Selections, res)
1577}
1578
1579func (ec *executionContext) fieldContext_SetTitleTimelineItem_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1580 fc = &graphql.FieldContext{
1581 Object: "SetTitleTimelineItem",
1582 Field: field,
1583 IsMethod: true,
1584 IsResolver: true,
1585 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1586 return nil, errors.New("field of type Time does not have child fields")
1587 },
1588 }
1589 return fc, nil
1590}
1591
1592func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
1593 fc, err := ec.fieldContext_SetTitleTimelineItem_title(ctx, field)
1594 if err != nil {
1595 return graphql.Null
1596 }
1597 ctx = graphql.WithFieldContext(ctx, fc)
1598 defer func() {
1599 if r := recover(); r != nil {
1600 ec.Error(ctx, ec.Recover(ctx, r))
1601 ret = graphql.Null
1602 }
1603 }()
1604 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1605 ctx = rctx // use context from middleware stack in children
1606 return obj.Title, nil
1607 })
1608 if err != nil {
1609 ec.Error(ctx, err)
1610 return graphql.Null
1611 }
1612 if resTmp == nil {
1613 if !graphql.HasFieldError(ctx, fc) {
1614 ec.Errorf(ctx, "must not be null")
1615 }
1616 return graphql.Null
1617 }
1618 res := resTmp.(string)
1619 fc.Result = res
1620 return ec.marshalNString2string(ctx, field.Selections, res)
1621}
1622
1623func (ec *executionContext) fieldContext_SetTitleTimelineItem_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1624 fc = &graphql.FieldContext{
1625 Object: "SetTitleTimelineItem",
1626 Field: field,
1627 IsMethod: false,
1628 IsResolver: false,
1629 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1630 return nil, errors.New("field of type String does not have child fields")
1631 },
1632 }
1633 return fc, nil
1634}
1635
1636func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
1637 fc, err := ec.fieldContext_SetTitleTimelineItem_was(ctx, field)
1638 if err != nil {
1639 return graphql.Null
1640 }
1641 ctx = graphql.WithFieldContext(ctx, fc)
1642 defer func() {
1643 if r := recover(); r != nil {
1644 ec.Error(ctx, ec.Recover(ctx, r))
1645 ret = graphql.Null
1646 }
1647 }()
1648 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1649 ctx = rctx // use context from middleware stack in children
1650 return obj.Was, nil
1651 })
1652 if err != nil {
1653 ec.Error(ctx, err)
1654 return graphql.Null
1655 }
1656 if resTmp == nil {
1657 if !graphql.HasFieldError(ctx, fc) {
1658 ec.Errorf(ctx, "must not be null")
1659 }
1660 return graphql.Null
1661 }
1662 res := resTmp.(string)
1663 fc.Result = res
1664 return ec.marshalNString2string(ctx, field.Selections, res)
1665}
1666
1667func (ec *executionContext) fieldContext_SetTitleTimelineItem_was(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1668 fc = &graphql.FieldContext{
1669 Object: "SetTitleTimelineItem",
1670 Field: field,
1671 IsMethod: false,
1672 IsResolver: false,
1673 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1674 return nil, errors.New("field of type String does not have child fields")
1675 },
1676 }
1677 return fc, nil
1678}
1679
1680func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
1681 fc, err := ec.fieldContext_TimelineItemConnection_edges(ctx, field)
1682 if err != nil {
1683 return graphql.Null
1684 }
1685 ctx = graphql.WithFieldContext(ctx, fc)
1686 defer func() {
1687 if r := recover(); r != nil {
1688 ec.Error(ctx, ec.Recover(ctx, r))
1689 ret = graphql.Null
1690 }
1691 }()
1692 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1693 ctx = rctx // use context from middleware stack in children
1694 return obj.Edges, nil
1695 })
1696 if err != nil {
1697 ec.Error(ctx, err)
1698 return graphql.Null
1699 }
1700 if resTmp == nil {
1701 if !graphql.HasFieldError(ctx, fc) {
1702 ec.Errorf(ctx, "must not be null")
1703 }
1704 return graphql.Null
1705 }
1706 res := resTmp.([]*models.TimelineItemEdge)
1707 fc.Result = res
1708 return ec.marshalNTimelineItemEdge2áágithubácomágitábugágitábugáapiágraphqlámodelsáTimelineItemEdgeá(ctx, field.Selections, res)
1709}
1710
1711func (ec *executionContext) fieldContext_TimelineItemConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1712 fc = &graphql.FieldContext{
1713 Object: "TimelineItemConnection",
1714 Field: field,
1715 IsMethod: false,
1716 IsResolver: false,
1717 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1718 switch field.Name {
1719 case "cursor":
1720 return ec.fieldContext_TimelineItemEdge_cursor(ctx, field)
1721 case "node":
1722 return ec.fieldContext_TimelineItemEdge_node(ctx, field)
1723 }
1724 return nil, fmt.Errorf("no field named %q was found under type TimelineItemEdge", field.Name)
1725 },
1726 }
1727 return fc, nil
1728}
1729
1730func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
1731 fc, err := ec.fieldContext_TimelineItemConnection_nodes(ctx, field)
1732 if err != nil {
1733 return graphql.Null
1734 }
1735 ctx = graphql.WithFieldContext(ctx, fc)
1736 defer func() {
1737 if r := recover(); r != nil {
1738 ec.Error(ctx, ec.Recover(ctx, r))
1739 ret = graphql.Null
1740 }
1741 }()
1742 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1743 ctx = rctx // use context from middleware stack in children
1744 return obj.Nodes, nil
1745 })
1746 if err != nil {
1747 ec.Error(ctx, err)
1748 return graphql.Null
1749 }
1750 if resTmp == nil {
1751 if !graphql.HasFieldError(ctx, fc) {
1752 ec.Errorf(ctx, "must not be null")
1753 }
1754 return graphql.Null
1755 }
1756 res := resTmp.([]bug.TimelineItem)
1757 fc.Result = res
1758 return ec.marshalNTimelineItem2ágithubácomágitábugágitábugáentitiesábugáTimelineItemá(ctx, field.Selections, res)
1759}
1760
1761func (ec *executionContext) fieldContext_TimelineItemConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1762 fc = &graphql.FieldContext{
1763 Object: "TimelineItemConnection",
1764 Field: field,
1765 IsMethod: false,
1766 IsResolver: false,
1767 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1768 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
1769 },
1770 }
1771 return fc, nil
1772}
1773
1774func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
1775 fc, err := ec.fieldContext_TimelineItemConnection_pageInfo(ctx, field)
1776 if err != nil {
1777 return graphql.Null
1778 }
1779 ctx = graphql.WithFieldContext(ctx, fc)
1780 defer func() {
1781 if r := recover(); r != nil {
1782 ec.Error(ctx, ec.Recover(ctx, r))
1783 ret = graphql.Null
1784 }
1785 }()
1786 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1787 ctx = rctx // use context from middleware stack in children
1788 return obj.PageInfo, nil
1789 })
1790 if err != nil {
1791 ec.Error(ctx, err)
1792 return graphql.Null
1793 }
1794 if resTmp == nil {
1795 if !graphql.HasFieldError(ctx, fc) {
1796 ec.Errorf(ctx, "must not be null")
1797 }
1798 return graphql.Null
1799 }
1800 res := resTmp.(*models.PageInfo)
1801 fc.Result = res
1802 return ec.marshalNPageInfo2ágithubácomágitábugágitábugáapiágraphqlámodelsáPageInfo(ctx, field.Selections, res)
1803}
1804
1805func (ec *executionContext) fieldContext_TimelineItemConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1806 fc = &graphql.FieldContext{
1807 Object: "TimelineItemConnection",
1808 Field: field,
1809 IsMethod: false,
1810 IsResolver: false,
1811 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1812 switch field.Name {
1813 case "hasNextPage":
1814 return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
1815 case "hasPreviousPage":
1816 return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
1817 case "startCursor":
1818 return ec.fieldContext_PageInfo_startCursor(ctx, field)
1819 case "endCursor":
1820 return ec.fieldContext_PageInfo_endCursor(ctx, field)
1821 }
1822 return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
1823 },
1824 }
1825 return fc, nil
1826}
1827
1828func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
1829 fc, err := ec.fieldContext_TimelineItemConnection_totalCount(ctx, field)
1830 if err != nil {
1831 return graphql.Null
1832 }
1833 ctx = graphql.WithFieldContext(ctx, fc)
1834 defer func() {
1835 if r := recover(); r != nil {
1836 ec.Error(ctx, ec.Recover(ctx, r))
1837 ret = graphql.Null
1838 }
1839 }()
1840 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1841 ctx = rctx // use context from middleware stack in children
1842 return obj.TotalCount, nil
1843 })
1844 if err != nil {
1845 ec.Error(ctx, err)
1846 return graphql.Null
1847 }
1848 if resTmp == nil {
1849 if !graphql.HasFieldError(ctx, fc) {
1850 ec.Errorf(ctx, "must not be null")
1851 }
1852 return graphql.Null
1853 }
1854 res := resTmp.(int)
1855 fc.Result = res
1856 return ec.marshalNInt2int(ctx, field.Selections, res)
1857}
1858
1859func (ec *executionContext) fieldContext_TimelineItemConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1860 fc = &graphql.FieldContext{
1861 Object: "TimelineItemConnection",
1862 Field: field,
1863 IsMethod: false,
1864 IsResolver: false,
1865 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1866 return nil, errors.New("field of type Int does not have child fields")
1867 },
1868 }
1869 return fc, nil
1870}
1871
1872func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
1873 fc, err := ec.fieldContext_TimelineItemEdge_cursor(ctx, field)
1874 if err != nil {
1875 return graphql.Null
1876 }
1877 ctx = graphql.WithFieldContext(ctx, fc)
1878 defer func() {
1879 if r := recover(); r != nil {
1880 ec.Error(ctx, ec.Recover(ctx, r))
1881 ret = graphql.Null
1882 }
1883 }()
1884 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1885 ctx = rctx // use context from middleware stack in children
1886 return obj.Cursor, nil
1887 })
1888 if err != nil {
1889 ec.Error(ctx, err)
1890 return graphql.Null
1891 }
1892 if resTmp == nil {
1893 if !graphql.HasFieldError(ctx, fc) {
1894 ec.Errorf(ctx, "must not be null")
1895 }
1896 return graphql.Null
1897 }
1898 res := resTmp.(string)
1899 fc.Result = res
1900 return ec.marshalNString2string(ctx, field.Selections, res)
1901}
1902
1903func (ec *executionContext) fieldContext_TimelineItemEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1904 fc = &graphql.FieldContext{
1905 Object: "TimelineItemEdge",
1906 Field: field,
1907 IsMethod: false,
1908 IsResolver: false,
1909 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1910 return nil, errors.New("field of type String does not have child fields")
1911 },
1912 }
1913 return fc, nil
1914}
1915
1916func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
1917 fc, err := ec.fieldContext_TimelineItemEdge_node(ctx, field)
1918 if err != nil {
1919 return graphql.Null
1920 }
1921 ctx = graphql.WithFieldContext(ctx, fc)
1922 defer func() {
1923 if r := recover(); r != nil {
1924 ec.Error(ctx, ec.Recover(ctx, r))
1925 ret = graphql.Null
1926 }
1927 }()
1928 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1929 ctx = rctx // use context from middleware stack in children
1930 return obj.Node, nil
1931 })
1932 if err != nil {
1933 ec.Error(ctx, err)
1934 return graphql.Null
1935 }
1936 if resTmp == nil {
1937 if !graphql.HasFieldError(ctx, fc) {
1938 ec.Errorf(ctx, "must not be null")
1939 }
1940 return graphql.Null
1941 }
1942 res := resTmp.(bug.TimelineItem)
1943 fc.Result = res
1944 return ec.marshalNTimelineItem2githubácomágitábugágitábugáentitiesábugáTimelineItem(ctx, field.Selections, res)
1945}
1946
1947func (ec *executionContext) fieldContext_TimelineItemEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1948 fc = &graphql.FieldContext{
1949 Object: "TimelineItemEdge",
1950 Field: field,
1951 IsMethod: false,
1952 IsResolver: false,
1953 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1954 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
1955 },
1956 }
1957 return fc, nil
1958}
1959
1960// endregion **************************** field.gotpl *****************************
1961
1962// region **************************** input.gotpl *****************************
1963
1964// endregion **************************** input.gotpl *****************************
1965
1966// region ************************** interface.gotpl ***************************
1967
1968func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
1969 switch obj := (obj).(type) {
1970 case nil:
1971 return graphql.Null
1972 case *bug.CreateTimelineItem:
1973 if obj == nil {
1974 return graphql.Null
1975 }
1976 return ec._CreateTimelineItem(ctx, sel, obj)
1977 case *bug.AddCommentTimelineItem:
1978 if obj == nil {
1979 return graphql.Null
1980 }
1981 return ec._AddCommentTimelineItem(ctx, sel, obj)
1982 case bug.LabelChangeTimelineItem:
1983 return ec._LabelChangeTimelineItem(ctx, sel, &obj)
1984 case *bug.LabelChangeTimelineItem:
1985 if obj == nil {
1986 return graphql.Null
1987 }
1988 return ec._LabelChangeTimelineItem(ctx, sel, obj)
1989 case bug.SetStatusTimelineItem:
1990 return ec._SetStatusTimelineItem(ctx, sel, &obj)
1991 case *bug.SetStatusTimelineItem:
1992 if obj == nil {
1993 return graphql.Null
1994 }
1995 return ec._SetStatusTimelineItem(ctx, sel, obj)
1996 case bug.SetTitleTimelineItem:
1997 return ec._SetTitleTimelineItem(ctx, sel, &obj)
1998 case *bug.SetTitleTimelineItem:
1999 if obj == nil {
2000 return graphql.Null
2001 }
2002 return ec._SetTitleTimelineItem(ctx, sel, obj)
2003 default:
2004 panic(fmt.Errorf("unexpected type %T", obj))
2005 }
2006}
2007
2008// endregion ************************** interface.gotpl ***************************
2009
2010// region **************************** object.gotpl ****************************
2011
2012var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
2013
2014func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2015 fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
2016
2017 out := graphql.NewFieldSet(fields)
2018 deferred := make(map[string]*graphql.FieldSet)
2019 for i, field := range fields {
2020 switch field.Name {
2021 case "__typename":
2022 out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
2023 case "id":
2024 field := field
2025
2026 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2027 defer func() {
2028 if r := recover(); r != nil {
2029 ec.Error(ctx, ec.Recover(ctx, r))
2030 }
2031 }()
2032 res = ec._AddCommentTimelineItem_id(ctx, field, obj)
2033 if res == graphql.Null {
2034 atomic.AddUint32(&fs.Invalids, 1)
2035 }
2036 return res
2037 }
2038
2039 if field.Deferrable != nil {
2040 dfs, ok := deferred[field.Deferrable.Label]
2041 di := 0
2042 if ok {
2043 dfs.AddField(field)
2044 di = len(dfs.Values) - 1
2045 } else {
2046 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2047 deferred[field.Deferrable.Label] = dfs
2048 }
2049 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2050 return innerFunc(ctx, dfs)
2051 })
2052
2053 // don't run the out.Concurrently() call below
2054 out.Values[i] = graphql.Null
2055 continue
2056 }
2057
2058 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2059 case "author":
2060 field := field
2061
2062 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2063 defer func() {
2064 if r := recover(); r != nil {
2065 ec.Error(ctx, ec.Recover(ctx, r))
2066 }
2067 }()
2068 res = ec._AddCommentTimelineItem_author(ctx, field, obj)
2069 if res == graphql.Null {
2070 atomic.AddUint32(&fs.Invalids, 1)
2071 }
2072 return res
2073 }
2074
2075 if field.Deferrable != nil {
2076 dfs, ok := deferred[field.Deferrable.Label]
2077 di := 0
2078 if ok {
2079 dfs.AddField(field)
2080 di = len(dfs.Values) - 1
2081 } else {
2082 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2083 deferred[field.Deferrable.Label] = dfs
2084 }
2085 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2086 return innerFunc(ctx, dfs)
2087 })
2088
2089 // don't run the out.Concurrently() call below
2090 out.Values[i] = graphql.Null
2091 continue
2092 }
2093
2094 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2095 case "message":
2096 out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
2097 if out.Values[i] == graphql.Null {
2098 atomic.AddUint32(&out.Invalids, 1)
2099 }
2100 case "messageIsEmpty":
2101 out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
2102 if out.Values[i] == graphql.Null {
2103 atomic.AddUint32(&out.Invalids, 1)
2104 }
2105 case "files":
2106 out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
2107 if out.Values[i] == graphql.Null {
2108 atomic.AddUint32(&out.Invalids, 1)
2109 }
2110 case "createdAt":
2111 field := field
2112
2113 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2114 defer func() {
2115 if r := recover(); r != nil {
2116 ec.Error(ctx, ec.Recover(ctx, r))
2117 }
2118 }()
2119 res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
2120 if res == graphql.Null {
2121 atomic.AddUint32(&fs.Invalids, 1)
2122 }
2123 return res
2124 }
2125
2126 if field.Deferrable != nil {
2127 dfs, ok := deferred[field.Deferrable.Label]
2128 di := 0
2129 if ok {
2130 dfs.AddField(field)
2131 di = len(dfs.Values) - 1
2132 } else {
2133 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2134 deferred[field.Deferrable.Label] = dfs
2135 }
2136 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2137 return innerFunc(ctx, dfs)
2138 })
2139
2140 // don't run the out.Concurrently() call below
2141 out.Values[i] = graphql.Null
2142 continue
2143 }
2144
2145 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2146 case "lastEdit":
2147 field := field
2148
2149 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2150 defer func() {
2151 if r := recover(); r != nil {
2152 ec.Error(ctx, ec.Recover(ctx, r))
2153 }
2154 }()
2155 res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
2156 if res == graphql.Null {
2157 atomic.AddUint32(&fs.Invalids, 1)
2158 }
2159 return res
2160 }
2161
2162 if field.Deferrable != nil {
2163 dfs, ok := deferred[field.Deferrable.Label]
2164 di := 0
2165 if ok {
2166 dfs.AddField(field)
2167 di = len(dfs.Values) - 1
2168 } else {
2169 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2170 deferred[field.Deferrable.Label] = dfs
2171 }
2172 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2173 return innerFunc(ctx, dfs)
2174 })
2175
2176 // don't run the out.Concurrently() call below
2177 out.Values[i] = graphql.Null
2178 continue
2179 }
2180
2181 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2182 case "edited":
2183 out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
2184 if out.Values[i] == graphql.Null {
2185 atomic.AddUint32(&out.Invalids, 1)
2186 }
2187 case "history":
2188 out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
2189 if out.Values[i] == graphql.Null {
2190 atomic.AddUint32(&out.Invalids, 1)
2191 }
2192 default:
2193 panic("unknown field " + strconv.Quote(field.Name))
2194 }
2195 }
2196 out.Dispatch(ctx)
2197 if out.Invalids > 0 {
2198 return graphql.Null
2199 }
2200
2201 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2202
2203 for label, dfs := range deferred {
2204 ec.processDeferredGroup(graphql.DeferredGroup{
2205 Label: label,
2206 Path: graphql.GetPath(ctx),
2207 FieldSet: dfs,
2208 Context: ctx,
2209 })
2210 }
2211
2212 return out
2213}
2214
2215var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
2216
2217func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
2218 fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
2219
2220 out := graphql.NewFieldSet(fields)
2221 deferred := make(map[string]*graphql.FieldSet)
2222 for i, field := range fields {
2223 switch field.Name {
2224 case "__typename":
2225 out.Values[i] = graphql.MarshalString("CommentHistoryStep")
2226 case "message":
2227 out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
2228 if out.Values[i] == graphql.Null {
2229 atomic.AddUint32(&out.Invalids, 1)
2230 }
2231 case "date":
2232 field := field
2233
2234 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2235 defer func() {
2236 if r := recover(); r != nil {
2237 ec.Error(ctx, ec.Recover(ctx, r))
2238 }
2239 }()
2240 res = ec._CommentHistoryStep_date(ctx, field, obj)
2241 if res == graphql.Null {
2242 atomic.AddUint32(&fs.Invalids, 1)
2243 }
2244 return res
2245 }
2246
2247 if field.Deferrable != nil {
2248 dfs, ok := deferred[field.Deferrable.Label]
2249 di := 0
2250 if ok {
2251 dfs.AddField(field)
2252 di = len(dfs.Values) - 1
2253 } else {
2254 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2255 deferred[field.Deferrable.Label] = dfs
2256 }
2257 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2258 return innerFunc(ctx, dfs)
2259 })
2260
2261 // don't run the out.Concurrently() call below
2262 out.Values[i] = graphql.Null
2263 continue
2264 }
2265
2266 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2267 default:
2268 panic("unknown field " + strconv.Quote(field.Name))
2269 }
2270 }
2271 out.Dispatch(ctx)
2272 if out.Invalids > 0 {
2273 return graphql.Null
2274 }
2275
2276 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2277
2278 for label, dfs := range deferred {
2279 ec.processDeferredGroup(graphql.DeferredGroup{
2280 Label: label,
2281 Path: graphql.GetPath(ctx),
2282 FieldSet: dfs,
2283 Context: ctx,
2284 })
2285 }
2286
2287 return out
2288}
2289
2290var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
2291
2292func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
2293 fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
2294
2295 out := graphql.NewFieldSet(fields)
2296 deferred := make(map[string]*graphql.FieldSet)
2297 for i, field := range fields {
2298 switch field.Name {
2299 case "__typename":
2300 out.Values[i] = graphql.MarshalString("CreateTimelineItem")
2301 case "id":
2302 field := field
2303
2304 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2305 defer func() {
2306 if r := recover(); r != nil {
2307 ec.Error(ctx, ec.Recover(ctx, r))
2308 }
2309 }()
2310 res = ec._CreateTimelineItem_id(ctx, field, obj)
2311 if res == graphql.Null {
2312 atomic.AddUint32(&fs.Invalids, 1)
2313 }
2314 return res
2315 }
2316
2317 if field.Deferrable != nil {
2318 dfs, ok := deferred[field.Deferrable.Label]
2319 di := 0
2320 if ok {
2321 dfs.AddField(field)
2322 di = len(dfs.Values) - 1
2323 } else {
2324 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2325 deferred[field.Deferrable.Label] = dfs
2326 }
2327 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2328 return innerFunc(ctx, dfs)
2329 })
2330
2331 // don't run the out.Concurrently() call below
2332 out.Values[i] = graphql.Null
2333 continue
2334 }
2335
2336 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2337 case "author":
2338 field := field
2339
2340 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2341 defer func() {
2342 if r := recover(); r != nil {
2343 ec.Error(ctx, ec.Recover(ctx, r))
2344 }
2345 }()
2346 res = ec._CreateTimelineItem_author(ctx, field, obj)
2347 if res == graphql.Null {
2348 atomic.AddUint32(&fs.Invalids, 1)
2349 }
2350 return res
2351 }
2352
2353 if field.Deferrable != nil {
2354 dfs, ok := deferred[field.Deferrable.Label]
2355 di := 0
2356 if ok {
2357 dfs.AddField(field)
2358 di = len(dfs.Values) - 1
2359 } else {
2360 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2361 deferred[field.Deferrable.Label] = dfs
2362 }
2363 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2364 return innerFunc(ctx, dfs)
2365 })
2366
2367 // don't run the out.Concurrently() call below
2368 out.Values[i] = graphql.Null
2369 continue
2370 }
2371
2372 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2373 case "message":
2374 out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
2375 if out.Values[i] == graphql.Null {
2376 atomic.AddUint32(&out.Invalids, 1)
2377 }
2378 case "messageIsEmpty":
2379 out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
2380 if out.Values[i] == graphql.Null {
2381 atomic.AddUint32(&out.Invalids, 1)
2382 }
2383 case "files":
2384 out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
2385 if out.Values[i] == graphql.Null {
2386 atomic.AddUint32(&out.Invalids, 1)
2387 }
2388 case "createdAt":
2389 field := field
2390
2391 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2392 defer func() {
2393 if r := recover(); r != nil {
2394 ec.Error(ctx, ec.Recover(ctx, r))
2395 }
2396 }()
2397 res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
2398 if res == graphql.Null {
2399 atomic.AddUint32(&fs.Invalids, 1)
2400 }
2401 return res
2402 }
2403
2404 if field.Deferrable != nil {
2405 dfs, ok := deferred[field.Deferrable.Label]
2406 di := 0
2407 if ok {
2408 dfs.AddField(field)
2409 di = len(dfs.Values) - 1
2410 } else {
2411 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2412 deferred[field.Deferrable.Label] = dfs
2413 }
2414 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2415 return innerFunc(ctx, dfs)
2416 })
2417
2418 // don't run the out.Concurrently() call below
2419 out.Values[i] = graphql.Null
2420 continue
2421 }
2422
2423 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2424 case "lastEdit":
2425 field := field
2426
2427 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2428 defer func() {
2429 if r := recover(); r != nil {
2430 ec.Error(ctx, ec.Recover(ctx, r))
2431 }
2432 }()
2433 res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
2434 if res == graphql.Null {
2435 atomic.AddUint32(&fs.Invalids, 1)
2436 }
2437 return res
2438 }
2439
2440 if field.Deferrable != nil {
2441 dfs, ok := deferred[field.Deferrable.Label]
2442 di := 0
2443 if ok {
2444 dfs.AddField(field)
2445 di = len(dfs.Values) - 1
2446 } else {
2447 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2448 deferred[field.Deferrable.Label] = dfs
2449 }
2450 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2451 return innerFunc(ctx, dfs)
2452 })
2453
2454 // don't run the out.Concurrently() call below
2455 out.Values[i] = graphql.Null
2456 continue
2457 }
2458
2459 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2460 case "edited":
2461 out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
2462 if out.Values[i] == graphql.Null {
2463 atomic.AddUint32(&out.Invalids, 1)
2464 }
2465 case "history":
2466 out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
2467 if out.Values[i] == graphql.Null {
2468 atomic.AddUint32(&out.Invalids, 1)
2469 }
2470 default:
2471 panic("unknown field " + strconv.Quote(field.Name))
2472 }
2473 }
2474 out.Dispatch(ctx)
2475 if out.Invalids > 0 {
2476 return graphql.Null
2477 }
2478
2479 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2480
2481 for label, dfs := range deferred {
2482 ec.processDeferredGroup(graphql.DeferredGroup{
2483 Label: label,
2484 Path: graphql.GetPath(ctx),
2485 FieldSet: dfs,
2486 Context: ctx,
2487 })
2488 }
2489
2490 return out
2491}
2492
2493var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
2494
2495func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
2496 fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
2497
2498 out := graphql.NewFieldSet(fields)
2499 deferred := make(map[string]*graphql.FieldSet)
2500 for i, field := range fields {
2501 switch field.Name {
2502 case "__typename":
2503 out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
2504 case "id":
2505 field := field
2506
2507 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2508 defer func() {
2509 if r := recover(); r != nil {
2510 ec.Error(ctx, ec.Recover(ctx, r))
2511 }
2512 }()
2513 res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
2514 if res == graphql.Null {
2515 atomic.AddUint32(&fs.Invalids, 1)
2516 }
2517 return res
2518 }
2519
2520 if field.Deferrable != nil {
2521 dfs, ok := deferred[field.Deferrable.Label]
2522 di := 0
2523 if ok {
2524 dfs.AddField(field)
2525 di = len(dfs.Values) - 1
2526 } else {
2527 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2528 deferred[field.Deferrable.Label] = dfs
2529 }
2530 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2531 return innerFunc(ctx, dfs)
2532 })
2533
2534 // don't run the out.Concurrently() call below
2535 out.Values[i] = graphql.Null
2536 continue
2537 }
2538
2539 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2540 case "author":
2541 field := field
2542
2543 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2544 defer func() {
2545 if r := recover(); r != nil {
2546 ec.Error(ctx, ec.Recover(ctx, r))
2547 }
2548 }()
2549 res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
2550 if res == graphql.Null {
2551 atomic.AddUint32(&fs.Invalids, 1)
2552 }
2553 return res
2554 }
2555
2556 if field.Deferrable != nil {
2557 dfs, ok := deferred[field.Deferrable.Label]
2558 di := 0
2559 if ok {
2560 dfs.AddField(field)
2561 di = len(dfs.Values) - 1
2562 } else {
2563 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2564 deferred[field.Deferrable.Label] = dfs
2565 }
2566 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2567 return innerFunc(ctx, dfs)
2568 })
2569
2570 // don't run the out.Concurrently() call below
2571 out.Values[i] = graphql.Null
2572 continue
2573 }
2574
2575 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2576 case "date":
2577 field := field
2578
2579 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2580 defer func() {
2581 if r := recover(); r != nil {
2582 ec.Error(ctx, ec.Recover(ctx, r))
2583 }
2584 }()
2585 res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
2586 if res == graphql.Null {
2587 atomic.AddUint32(&fs.Invalids, 1)
2588 }
2589 return res
2590 }
2591
2592 if field.Deferrable != nil {
2593 dfs, ok := deferred[field.Deferrable.Label]
2594 di := 0
2595 if ok {
2596 dfs.AddField(field)
2597 di = len(dfs.Values) - 1
2598 } else {
2599 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2600 deferred[field.Deferrable.Label] = dfs
2601 }
2602 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2603 return innerFunc(ctx, dfs)
2604 })
2605
2606 // don't run the out.Concurrently() call below
2607 out.Values[i] = graphql.Null
2608 continue
2609 }
2610
2611 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2612 case "added":
2613 out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
2614 if out.Values[i] == graphql.Null {
2615 atomic.AddUint32(&out.Invalids, 1)
2616 }
2617 case "removed":
2618 out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
2619 if out.Values[i] == graphql.Null {
2620 atomic.AddUint32(&out.Invalids, 1)
2621 }
2622 default:
2623 panic("unknown field " + strconv.Quote(field.Name))
2624 }
2625 }
2626 out.Dispatch(ctx)
2627 if out.Invalids > 0 {
2628 return graphql.Null
2629 }
2630
2631 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2632
2633 for label, dfs := range deferred {
2634 ec.processDeferredGroup(graphql.DeferredGroup{
2635 Label: label,
2636 Path: graphql.GetPath(ctx),
2637 FieldSet: dfs,
2638 Context: ctx,
2639 })
2640 }
2641
2642 return out
2643}
2644
2645var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
2646
2647func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
2648 fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
2649
2650 out := graphql.NewFieldSet(fields)
2651 deferred := make(map[string]*graphql.FieldSet)
2652 for i, field := range fields {
2653 switch field.Name {
2654 case "__typename":
2655 out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
2656 case "id":
2657 field := field
2658
2659 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2660 defer func() {
2661 if r := recover(); r != nil {
2662 ec.Error(ctx, ec.Recover(ctx, r))
2663 }
2664 }()
2665 res = ec._SetStatusTimelineItem_id(ctx, field, obj)
2666 if res == graphql.Null {
2667 atomic.AddUint32(&fs.Invalids, 1)
2668 }
2669 return res
2670 }
2671
2672 if field.Deferrable != nil {
2673 dfs, ok := deferred[field.Deferrable.Label]
2674 di := 0
2675 if ok {
2676 dfs.AddField(field)
2677 di = len(dfs.Values) - 1
2678 } else {
2679 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2680 deferred[field.Deferrable.Label] = dfs
2681 }
2682 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2683 return innerFunc(ctx, dfs)
2684 })
2685
2686 // don't run the out.Concurrently() call below
2687 out.Values[i] = graphql.Null
2688 continue
2689 }
2690
2691 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2692 case "author":
2693 field := field
2694
2695 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2696 defer func() {
2697 if r := recover(); r != nil {
2698 ec.Error(ctx, ec.Recover(ctx, r))
2699 }
2700 }()
2701 res = ec._SetStatusTimelineItem_author(ctx, field, obj)
2702 if res == graphql.Null {
2703 atomic.AddUint32(&fs.Invalids, 1)
2704 }
2705 return res
2706 }
2707
2708 if field.Deferrable != nil {
2709 dfs, ok := deferred[field.Deferrable.Label]
2710 di := 0
2711 if ok {
2712 dfs.AddField(field)
2713 di = len(dfs.Values) - 1
2714 } else {
2715 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2716 deferred[field.Deferrable.Label] = dfs
2717 }
2718 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2719 return innerFunc(ctx, dfs)
2720 })
2721
2722 // don't run the out.Concurrently() call below
2723 out.Values[i] = graphql.Null
2724 continue
2725 }
2726
2727 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2728 case "date":
2729 field := field
2730
2731 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2732 defer func() {
2733 if r := recover(); r != nil {
2734 ec.Error(ctx, ec.Recover(ctx, r))
2735 }
2736 }()
2737 res = ec._SetStatusTimelineItem_date(ctx, field, obj)
2738 if res == graphql.Null {
2739 atomic.AddUint32(&fs.Invalids, 1)
2740 }
2741 return res
2742 }
2743
2744 if field.Deferrable != nil {
2745 dfs, ok := deferred[field.Deferrable.Label]
2746 di := 0
2747 if ok {
2748 dfs.AddField(field)
2749 di = len(dfs.Values) - 1
2750 } else {
2751 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2752 deferred[field.Deferrable.Label] = dfs
2753 }
2754 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2755 return innerFunc(ctx, dfs)
2756 })
2757
2758 // don't run the out.Concurrently() call below
2759 out.Values[i] = graphql.Null
2760 continue
2761 }
2762
2763 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2764 case "status":
2765 out.Values[i] = ec._SetStatusTimelineItem_status(ctx, field, obj)
2766 if out.Values[i] == graphql.Null {
2767 atomic.AddUint32(&out.Invalids, 1)
2768 }
2769 default:
2770 panic("unknown field " + strconv.Quote(field.Name))
2771 }
2772 }
2773 out.Dispatch(ctx)
2774 if out.Invalids > 0 {
2775 return graphql.Null
2776 }
2777
2778 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2779
2780 for label, dfs := range deferred {
2781 ec.processDeferredGroup(graphql.DeferredGroup{
2782 Label: label,
2783 Path: graphql.GetPath(ctx),
2784 FieldSet: dfs,
2785 Context: ctx,
2786 })
2787 }
2788
2789 return out
2790}
2791
2792var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
2793
2794func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
2795 fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
2796
2797 out := graphql.NewFieldSet(fields)
2798 deferred := make(map[string]*graphql.FieldSet)
2799 for i, field := range fields {
2800 switch field.Name {
2801 case "__typename":
2802 out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
2803 case "id":
2804 field := field
2805
2806 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2807 defer func() {
2808 if r := recover(); r != nil {
2809 ec.Error(ctx, ec.Recover(ctx, r))
2810 }
2811 }()
2812 res = ec._SetTitleTimelineItem_id(ctx, field, obj)
2813 if res == graphql.Null {
2814 atomic.AddUint32(&fs.Invalids, 1)
2815 }
2816 return res
2817 }
2818
2819 if field.Deferrable != nil {
2820 dfs, ok := deferred[field.Deferrable.Label]
2821 di := 0
2822 if ok {
2823 dfs.AddField(field)
2824 di = len(dfs.Values) - 1
2825 } else {
2826 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2827 deferred[field.Deferrable.Label] = dfs
2828 }
2829 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2830 return innerFunc(ctx, dfs)
2831 })
2832
2833 // don't run the out.Concurrently() call below
2834 out.Values[i] = graphql.Null
2835 continue
2836 }
2837
2838 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2839 case "author":
2840 field := field
2841
2842 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2843 defer func() {
2844 if r := recover(); r != nil {
2845 ec.Error(ctx, ec.Recover(ctx, r))
2846 }
2847 }()
2848 res = ec._SetTitleTimelineItem_author(ctx, field, obj)
2849 if res == graphql.Null {
2850 atomic.AddUint32(&fs.Invalids, 1)
2851 }
2852 return res
2853 }
2854
2855 if field.Deferrable != nil {
2856 dfs, ok := deferred[field.Deferrable.Label]
2857 di := 0
2858 if ok {
2859 dfs.AddField(field)
2860 di = len(dfs.Values) - 1
2861 } else {
2862 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2863 deferred[field.Deferrable.Label] = dfs
2864 }
2865 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2866 return innerFunc(ctx, dfs)
2867 })
2868
2869 // don't run the out.Concurrently() call below
2870 out.Values[i] = graphql.Null
2871 continue
2872 }
2873
2874 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2875 case "date":
2876 field := field
2877
2878 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2879 defer func() {
2880 if r := recover(); r != nil {
2881 ec.Error(ctx, ec.Recover(ctx, r))
2882 }
2883 }()
2884 res = ec._SetTitleTimelineItem_date(ctx, field, obj)
2885 if res == graphql.Null {
2886 atomic.AddUint32(&fs.Invalids, 1)
2887 }
2888 return res
2889 }
2890
2891 if field.Deferrable != nil {
2892 dfs, ok := deferred[field.Deferrable.Label]
2893 di := 0
2894 if ok {
2895 dfs.AddField(field)
2896 di = len(dfs.Values) - 1
2897 } else {
2898 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2899 deferred[field.Deferrable.Label] = dfs
2900 }
2901 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2902 return innerFunc(ctx, dfs)
2903 })
2904
2905 // don't run the out.Concurrently() call below
2906 out.Values[i] = graphql.Null
2907 continue
2908 }
2909
2910 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2911 case "title":
2912 out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
2913 if out.Values[i] == graphql.Null {
2914 atomic.AddUint32(&out.Invalids, 1)
2915 }
2916 case "was":
2917 out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
2918 if out.Values[i] == graphql.Null {
2919 atomic.AddUint32(&out.Invalids, 1)
2920 }
2921 default:
2922 panic("unknown field " + strconv.Quote(field.Name))
2923 }
2924 }
2925 out.Dispatch(ctx)
2926 if out.Invalids > 0 {
2927 return graphql.Null
2928 }
2929
2930 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2931
2932 for label, dfs := range deferred {
2933 ec.processDeferredGroup(graphql.DeferredGroup{
2934 Label: label,
2935 Path: graphql.GetPath(ctx),
2936 FieldSet: dfs,
2937 Context: ctx,
2938 })
2939 }
2940
2941 return out
2942}
2943
2944var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
2945
2946func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
2947 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
2948
2949 out := graphql.NewFieldSet(fields)
2950 deferred := make(map[string]*graphql.FieldSet)
2951 for i, field := range fields {
2952 switch field.Name {
2953 case "__typename":
2954 out.Values[i] = graphql.MarshalString("TimelineItemConnection")
2955 case "edges":
2956 out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
2957 if out.Values[i] == graphql.Null {
2958 out.Invalids++
2959 }
2960 case "nodes":
2961 out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
2962 if out.Values[i] == graphql.Null {
2963 out.Invalids++
2964 }
2965 case "pageInfo":
2966 out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
2967 if out.Values[i] == graphql.Null {
2968 out.Invalids++
2969 }
2970 case "totalCount":
2971 out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
2972 if out.Values[i] == graphql.Null {
2973 out.Invalids++
2974 }
2975 default:
2976 panic("unknown field " + strconv.Quote(field.Name))
2977 }
2978 }
2979 out.Dispatch(ctx)
2980 if out.Invalids > 0 {
2981 return graphql.Null
2982 }
2983
2984 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2985
2986 for label, dfs := range deferred {
2987 ec.processDeferredGroup(graphql.DeferredGroup{
2988 Label: label,
2989 Path: graphql.GetPath(ctx),
2990 FieldSet: dfs,
2991 Context: ctx,
2992 })
2993 }
2994
2995 return out
2996}
2997
2998var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
2999
3000func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
3001 fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
3002
3003 out := graphql.NewFieldSet(fields)
3004 deferred := make(map[string]*graphql.FieldSet)
3005 for i, field := range fields {
3006 switch field.Name {
3007 case "__typename":
3008 out.Values[i] = graphql.MarshalString("TimelineItemEdge")
3009 case "cursor":
3010 out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
3011 if out.Values[i] == graphql.Null {
3012 out.Invalids++
3013 }
3014 case "node":
3015 out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
3016 if out.Values[i] == graphql.Null {
3017 out.Invalids++
3018 }
3019 default:
3020 panic("unknown field " + strconv.Quote(field.Name))
3021 }
3022 }
3023 out.Dispatch(ctx)
3024 if out.Invalids > 0 {
3025 return graphql.Null
3026 }
3027
3028 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
3029
3030 for label, dfs := range deferred {
3031 ec.processDeferredGroup(graphql.DeferredGroup{
3032 Label: label,
3033 Path: graphql.GetPath(ctx),
3034 FieldSet: dfs,
3035 Context: ctx,
3036 })
3037 }
3038
3039 return out
3040}
3041
3042// endregion **************************** object.gotpl ****************************
3043
3044// region ***************************** type.gotpl *****************************
3045
3046func (ec *executionContext) marshalNCommentHistoryStep2githubácomágitábugágitábugáentitiesábugáCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
3047 return ec._CommentHistoryStep(ctx, sel, &v)
3048}
3049
3050func (ec *executionContext) marshalNCommentHistoryStep2ágithubácomágitábugágitábugáentitiesábugáCommentHistoryStepá(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
3051 ret := make(graphql.Array, len(v))
3052 var wg sync.WaitGroup
3053 isLen1 := len(v) == 1
3054 if !isLen1 {
3055 wg.Add(len(v))
3056 }
3057 for i := range v {
3058 i := i
3059 fc := &graphql.FieldContext{
3060 Index: &i,
3061 Result: &v[i],
3062 }
3063 ctx := graphql.WithFieldContext(ctx, fc)
3064 f := func(i int) {
3065 defer func() {
3066 if r := recover(); r != nil {
3067 ec.Error(ctx, ec.Recover(ctx, r))
3068 ret = nil
3069 }
3070 }()
3071 if !isLen1 {
3072 defer wg.Done()
3073 }
3074 ret[i] = ec.marshalNCommentHistoryStep2githubácomágitábugágitábugáentitiesábugáCommentHistoryStep(ctx, sel, v[i])
3075 }
3076 if isLen1 {
3077 f(i)
3078 } else {
3079 go f(i)
3080 }
3081
3082 }
3083 wg.Wait()
3084
3085 for _, e := range ret {
3086 if e == graphql.Null {
3087 return graphql.Null
3088 }
3089 }
3090
3091 return ret
3092}
3093
3094func (ec *executionContext) marshalNTimelineItem2githubácomágitábugágitábugáentitiesábugáTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
3095 if v == nil {
3096 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
3097 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
3098 }
3099 return graphql.Null
3100 }
3101 return ec._TimelineItem(ctx, sel, v)
3102}
3103
3104func (ec *executionContext) marshalNTimelineItem2ágithubácomágitábugágitábugáentitiesábugáTimelineItemá(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
3105 ret := make(graphql.Array, len(v))
3106 var wg sync.WaitGroup
3107 isLen1 := len(v) == 1
3108 if !isLen1 {
3109 wg.Add(len(v))
3110 }
3111 for i := range v {
3112 i := i
3113 fc := &graphql.FieldContext{
3114 Index: &i,
3115 Result: &v[i],
3116 }
3117 ctx := graphql.WithFieldContext(ctx, fc)
3118 f := func(i int) {
3119 defer func() {
3120 if r := recover(); r != nil {
3121 ec.Error(ctx, ec.Recover(ctx, r))
3122 ret = nil
3123 }
3124 }()
3125 if !isLen1 {
3126 defer wg.Done()
3127 }
3128 ret[i] = ec.marshalNTimelineItem2githubácomágitábugágitábugáentitiesábugáTimelineItem(ctx, sel, v[i])
3129 }
3130 if isLen1 {
3131 f(i)
3132 } else {
3133 go f(i)
3134 }
3135
3136 }
3137 wg.Wait()
3138
3139 for _, e := range ret {
3140 if e == graphql.Null {
3141 return graphql.Null
3142 }
3143 }
3144
3145 return ret
3146}
3147
3148func (ec *executionContext) marshalNTimelineItemConnection2githubácomágitábugágitábugáapiágraphqlámodelsáTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
3149 return ec._TimelineItemConnection(ctx, sel, &v)
3150}
3151
3152func (ec *executionContext) marshalNTimelineItemConnection2ágithubácomágitábugágitábugáapiágraphqlámodelsáTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
3153 if v == nil {
3154 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
3155 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
3156 }
3157 return graphql.Null
3158 }
3159 return ec._TimelineItemConnection(ctx, sel, v)
3160}
3161
3162func (ec *executionContext) marshalNTimelineItemEdge2áágithubácomágitábugágitábugáapiágraphqlámodelsáTimelineItemEdgeá(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
3163 ret := make(graphql.Array, len(v))
3164 var wg sync.WaitGroup
3165 isLen1 := len(v) == 1
3166 if !isLen1 {
3167 wg.Add(len(v))
3168 }
3169 for i := range v {
3170 i := i
3171 fc := &graphql.FieldContext{
3172 Index: &i,
3173 Result: &v[i],
3174 }
3175 ctx := graphql.WithFieldContext(ctx, fc)
3176 f := func(i int) {
3177 defer func() {
3178 if r := recover(); r != nil {
3179 ec.Error(ctx, ec.Recover(ctx, r))
3180 ret = nil
3181 }
3182 }()
3183 if !isLen1 {
3184 defer wg.Done()
3185 }
3186 ret[i] = ec.marshalNTimelineItemEdge2ágithubácomágitábugágitábugáapiágraphqlámodelsáTimelineItemEdge(ctx, sel, v[i])
3187 }
3188 if isLen1 {
3189 f(i)
3190 } else {
3191 go f(i)
3192 }
3193
3194 }
3195 wg.Wait()
3196
3197 for _, e := range ret {
3198 if e == graphql.Null {
3199 return graphql.Null
3200 }
3201 }
3202
3203 return ret
3204}
3205
3206func (ec *executionContext) marshalNTimelineItemEdge2ágithubácomágitábugágitábugáapiágraphqlámodelsáTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
3207 if v == nil {
3208 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
3209 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
3210 }
3211 return graphql.Null
3212 }
3213 return ec._TimelineItemEdge(ctx, sel, v)
3214}
3215
3216// endregion ***************************** type.gotpl *****************************