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