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/atomic"
11 "time"
12
13 "github.com/99designs/gqlgen/graphql"
14 "github.com/git-bug/git-bug/api/graphql/models"
15 "github.com/git-bug/git-bug/entities/bug"
16 "github.com/git-bug/git-bug/entities/common"
17 "github.com/git-bug/git-bug/entity"
18 "github.com/git-bug/git-bug/repository"
19 "github.com/vektah/gqlparser/v2/ast"
20)
21
22// region ************************** generated!.gotpl **************************
23
24type BugAddCommentOperationResolver interface {
25 Author(ctx context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error)
26}
27type BugCreateOperationResolver interface {
28 Author(ctx context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error)
29}
30type BugEditCommentOperationResolver interface {
31 Author(ctx context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error)
32}
33type BugLabelChangeOperationResolver interface {
34 Author(ctx context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error)
35}
36type BugSetStatusOperationResolver interface {
37 Author(ctx context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error)
38}
39type BugSetTitleOperationResolver interface {
40 Author(ctx context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error)
41}
42
43// endregion ************************** generated!.gotpl **************************
44
45// region ***************************** args.gotpl *****************************
46
47// endregion ***************************** args.gotpl *****************************
48
49// region ************************** directives.gotpl **************************
50
51// endregion ************************** directives.gotpl **************************
52
53// region **************************** field.gotpl *****************************
54
55func (ec *executionContext) _BugAddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
56 fc, err := ec.fieldContext_BugAddCommentOperation_id(ctx, field)
57 if err != nil {
58 return graphql.Null
59 }
60 ctx = graphql.WithFieldContext(ctx, fc)
61 defer func() {
62 if r := recover(); r != nil {
63 ec.Error(ctx, ec.Recover(ctx, r))
64 ret = graphql.Null
65 }
66 }()
67 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
68 ctx = rctx // use context from middleware stack in children
69 return obj.Id(), nil
70 })
71 if err != nil {
72 ec.Error(ctx, err)
73 return graphql.Null
74 }
75 if resTmp == nil {
76 if !graphql.HasFieldError(ctx, fc) {
77 ec.Errorf(ctx, "must not be null")
78 }
79 return graphql.Null
80 }
81 res := resTmp.(entity.Id)
82 fc.Result = res
83 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
84}
85
86func (ec *executionContext) fieldContext_BugAddCommentOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
87 fc = &graphql.FieldContext{
88 Object: "BugAddCommentOperation",
89 Field: field,
90 IsMethod: true,
91 IsResolver: false,
92 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
93 return nil, errors.New("field of type ID does not have child fields")
94 },
95 }
96 return fc, nil
97}
98
99func (ec *executionContext) _BugAddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
100 fc, err := ec.fieldContext_BugAddCommentOperation_author(ctx, field)
101 if err != nil {
102 return graphql.Null
103 }
104 ctx = graphql.WithFieldContext(ctx, fc)
105 defer func() {
106 if r := recover(); r != nil {
107 ec.Error(ctx, ec.Recover(ctx, r))
108 ret = graphql.Null
109 }
110 }()
111 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
112 ctx = rctx // use context from middleware stack in children
113 return ec.resolvers.BugAddCommentOperation().Author(rctx, obj)
114 })
115 if err != nil {
116 ec.Error(ctx, err)
117 return graphql.Null
118 }
119 if resTmp == nil {
120 if !graphql.HasFieldError(ctx, fc) {
121 ec.Errorf(ctx, "must not be null")
122 }
123 return graphql.Null
124 }
125 res := resTmp.(models.IdentityWrapper)
126 fc.Result = res
127 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
128}
129
130func (ec *executionContext) fieldContext_BugAddCommentOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
131 fc = &graphql.FieldContext{
132 Object: "BugAddCommentOperation",
133 Field: field,
134 IsMethod: true,
135 IsResolver: true,
136 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
137 switch field.Name {
138 case "id":
139 return ec.fieldContext_Identity_id(ctx, field)
140 case "humanId":
141 return ec.fieldContext_Identity_humanId(ctx, field)
142 case "name":
143 return ec.fieldContext_Identity_name(ctx, field)
144 case "email":
145 return ec.fieldContext_Identity_email(ctx, field)
146 case "login":
147 return ec.fieldContext_Identity_login(ctx, field)
148 case "displayName":
149 return ec.fieldContext_Identity_displayName(ctx, field)
150 case "avatarUrl":
151 return ec.fieldContext_Identity_avatarUrl(ctx, field)
152 case "isProtected":
153 return ec.fieldContext_Identity_isProtected(ctx, field)
154 }
155 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
156 },
157 }
158 return fc, nil
159}
160
161func (ec *executionContext) _BugAddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
162 fc, err := ec.fieldContext_BugAddCommentOperation_date(ctx, field)
163 if err != nil {
164 return graphql.Null
165 }
166 ctx = graphql.WithFieldContext(ctx, fc)
167 defer func() {
168 if r := recover(); r != nil {
169 ec.Error(ctx, ec.Recover(ctx, r))
170 ret = graphql.Null
171 }
172 }()
173 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
174 ctx = rctx // use context from middleware stack in children
175 return obj.Time(), nil
176 })
177 if err != nil {
178 ec.Error(ctx, err)
179 return graphql.Null
180 }
181 if resTmp == nil {
182 if !graphql.HasFieldError(ctx, fc) {
183 ec.Errorf(ctx, "must not be null")
184 }
185 return graphql.Null
186 }
187 res := resTmp.(time.Time)
188 fc.Result = res
189 return ec.marshalNTime2timeáTime(ctx, field.Selections, res)
190}
191
192func (ec *executionContext) fieldContext_BugAddCommentOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
193 fc = &graphql.FieldContext{
194 Object: "BugAddCommentOperation",
195 Field: field,
196 IsMethod: true,
197 IsResolver: false,
198 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
199 return nil, errors.New("field of type Time does not have child fields")
200 },
201 }
202 return fc, nil
203}
204
205func (ec *executionContext) _BugAddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
206 fc, err := ec.fieldContext_BugAddCommentOperation_message(ctx, field)
207 if err != nil {
208 return graphql.Null
209 }
210 ctx = graphql.WithFieldContext(ctx, fc)
211 defer func() {
212 if r := recover(); r != nil {
213 ec.Error(ctx, ec.Recover(ctx, r))
214 ret = graphql.Null
215 }
216 }()
217 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
218 ctx = rctx // use context from middleware stack in children
219 return obj.Message, nil
220 })
221 if err != nil {
222 ec.Error(ctx, err)
223 return graphql.Null
224 }
225 if resTmp == nil {
226 if !graphql.HasFieldError(ctx, fc) {
227 ec.Errorf(ctx, "must not be null")
228 }
229 return graphql.Null
230 }
231 res := resTmp.(string)
232 fc.Result = res
233 return ec.marshalNString2string(ctx, field.Selections, res)
234}
235
236func (ec *executionContext) fieldContext_BugAddCommentOperation_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
237 fc = &graphql.FieldContext{
238 Object: "BugAddCommentOperation",
239 Field: field,
240 IsMethod: false,
241 IsResolver: false,
242 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
243 return nil, errors.New("field of type String does not have child fields")
244 },
245 }
246 return fc, nil
247}
248
249func (ec *executionContext) _BugAddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
250 fc, err := ec.fieldContext_BugAddCommentOperation_files(ctx, field)
251 if err != nil {
252 return graphql.Null
253 }
254 ctx = graphql.WithFieldContext(ctx, fc)
255 defer func() {
256 if r := recover(); r != nil {
257 ec.Error(ctx, ec.Recover(ctx, r))
258 ret = graphql.Null
259 }
260 }()
261 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
262 ctx = rctx // use context from middleware stack in children
263 return obj.Files, nil
264 })
265 if err != nil {
266 ec.Error(ctx, err)
267 return graphql.Null
268 }
269 if resTmp == nil {
270 if !graphql.HasFieldError(ctx, fc) {
271 ec.Errorf(ctx, "must not be null")
272 }
273 return graphql.Null
274 }
275 res := resTmp.([]repository.Hash)
276 fc.Result = res
277 return ec.marshalNHash2ágithubácomágitábugágitábugárepositoryáHashá(ctx, field.Selections, res)
278}
279
280func (ec *executionContext) fieldContext_BugAddCommentOperation_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
281 fc = &graphql.FieldContext{
282 Object: "BugAddCommentOperation",
283 Field: field,
284 IsMethod: false,
285 IsResolver: false,
286 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
287 return nil, errors.New("field of type Hash does not have child fields")
288 },
289 }
290 return fc, nil
291}
292
293func (ec *executionContext) _BugCreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
294 fc, err := ec.fieldContext_BugCreateOperation_id(ctx, field)
295 if err != nil {
296 return graphql.Null
297 }
298 ctx = graphql.WithFieldContext(ctx, fc)
299 defer func() {
300 if r := recover(); r != nil {
301 ec.Error(ctx, ec.Recover(ctx, r))
302 ret = graphql.Null
303 }
304 }()
305 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
306 ctx = rctx // use context from middleware stack in children
307 return obj.Id(), nil
308 })
309 if err != nil {
310 ec.Error(ctx, err)
311 return graphql.Null
312 }
313 if resTmp == nil {
314 if !graphql.HasFieldError(ctx, fc) {
315 ec.Errorf(ctx, "must not be null")
316 }
317 return graphql.Null
318 }
319 res := resTmp.(entity.Id)
320 fc.Result = res
321 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
322}
323
324func (ec *executionContext) fieldContext_BugCreateOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
325 fc = &graphql.FieldContext{
326 Object: "BugCreateOperation",
327 Field: field,
328 IsMethod: true,
329 IsResolver: false,
330 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
331 return nil, errors.New("field of type ID does not have child fields")
332 },
333 }
334 return fc, nil
335}
336
337func (ec *executionContext) _BugCreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
338 fc, err := ec.fieldContext_BugCreateOperation_author(ctx, field)
339 if err != nil {
340 return graphql.Null
341 }
342 ctx = graphql.WithFieldContext(ctx, fc)
343 defer func() {
344 if r := recover(); r != nil {
345 ec.Error(ctx, ec.Recover(ctx, r))
346 ret = graphql.Null
347 }
348 }()
349 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
350 ctx = rctx // use context from middleware stack in children
351 return ec.resolvers.BugCreateOperation().Author(rctx, obj)
352 })
353 if err != nil {
354 ec.Error(ctx, err)
355 return graphql.Null
356 }
357 if resTmp == nil {
358 if !graphql.HasFieldError(ctx, fc) {
359 ec.Errorf(ctx, "must not be null")
360 }
361 return graphql.Null
362 }
363 res := resTmp.(models.IdentityWrapper)
364 fc.Result = res
365 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
366}
367
368func (ec *executionContext) fieldContext_BugCreateOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
369 fc = &graphql.FieldContext{
370 Object: "BugCreateOperation",
371 Field: field,
372 IsMethod: true,
373 IsResolver: true,
374 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
375 switch field.Name {
376 case "id":
377 return ec.fieldContext_Identity_id(ctx, field)
378 case "humanId":
379 return ec.fieldContext_Identity_humanId(ctx, field)
380 case "name":
381 return ec.fieldContext_Identity_name(ctx, field)
382 case "email":
383 return ec.fieldContext_Identity_email(ctx, field)
384 case "login":
385 return ec.fieldContext_Identity_login(ctx, field)
386 case "displayName":
387 return ec.fieldContext_Identity_displayName(ctx, field)
388 case "avatarUrl":
389 return ec.fieldContext_Identity_avatarUrl(ctx, field)
390 case "isProtected":
391 return ec.fieldContext_Identity_isProtected(ctx, field)
392 }
393 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
394 },
395 }
396 return fc, nil
397}
398
399func (ec *executionContext) _BugCreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
400 fc, err := ec.fieldContext_BugCreateOperation_date(ctx, field)
401 if err != nil {
402 return graphql.Null
403 }
404 ctx = graphql.WithFieldContext(ctx, fc)
405 defer func() {
406 if r := recover(); r != nil {
407 ec.Error(ctx, ec.Recover(ctx, r))
408 ret = graphql.Null
409 }
410 }()
411 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
412 ctx = rctx // use context from middleware stack in children
413 return obj.Time(), nil
414 })
415 if err != nil {
416 ec.Error(ctx, err)
417 return graphql.Null
418 }
419 if resTmp == nil {
420 if !graphql.HasFieldError(ctx, fc) {
421 ec.Errorf(ctx, "must not be null")
422 }
423 return graphql.Null
424 }
425 res := resTmp.(time.Time)
426 fc.Result = res
427 return ec.marshalNTime2timeáTime(ctx, field.Selections, res)
428}
429
430func (ec *executionContext) fieldContext_BugCreateOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
431 fc = &graphql.FieldContext{
432 Object: "BugCreateOperation",
433 Field: field,
434 IsMethod: true,
435 IsResolver: false,
436 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
437 return nil, errors.New("field of type Time does not have child fields")
438 },
439 }
440 return fc, nil
441}
442
443func (ec *executionContext) _BugCreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
444 fc, err := ec.fieldContext_BugCreateOperation_title(ctx, field)
445 if err != nil {
446 return graphql.Null
447 }
448 ctx = graphql.WithFieldContext(ctx, fc)
449 defer func() {
450 if r := recover(); r != nil {
451 ec.Error(ctx, ec.Recover(ctx, r))
452 ret = graphql.Null
453 }
454 }()
455 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
456 ctx = rctx // use context from middleware stack in children
457 return obj.Title, nil
458 })
459 if err != nil {
460 ec.Error(ctx, err)
461 return graphql.Null
462 }
463 if resTmp == nil {
464 if !graphql.HasFieldError(ctx, fc) {
465 ec.Errorf(ctx, "must not be null")
466 }
467 return graphql.Null
468 }
469 res := resTmp.(string)
470 fc.Result = res
471 return ec.marshalNString2string(ctx, field.Selections, res)
472}
473
474func (ec *executionContext) fieldContext_BugCreateOperation_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
475 fc = &graphql.FieldContext{
476 Object: "BugCreateOperation",
477 Field: field,
478 IsMethod: false,
479 IsResolver: false,
480 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
481 return nil, errors.New("field of type String does not have child fields")
482 },
483 }
484 return fc, nil
485}
486
487func (ec *executionContext) _BugCreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
488 fc, err := ec.fieldContext_BugCreateOperation_message(ctx, field)
489 if err != nil {
490 return graphql.Null
491 }
492 ctx = graphql.WithFieldContext(ctx, fc)
493 defer func() {
494 if r := recover(); r != nil {
495 ec.Error(ctx, ec.Recover(ctx, r))
496 ret = graphql.Null
497 }
498 }()
499 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
500 ctx = rctx // use context from middleware stack in children
501 return obj.Message, nil
502 })
503 if err != nil {
504 ec.Error(ctx, err)
505 return graphql.Null
506 }
507 if resTmp == nil {
508 if !graphql.HasFieldError(ctx, fc) {
509 ec.Errorf(ctx, "must not be null")
510 }
511 return graphql.Null
512 }
513 res := resTmp.(string)
514 fc.Result = res
515 return ec.marshalNString2string(ctx, field.Selections, res)
516}
517
518func (ec *executionContext) fieldContext_BugCreateOperation_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
519 fc = &graphql.FieldContext{
520 Object: "BugCreateOperation",
521 Field: field,
522 IsMethod: false,
523 IsResolver: false,
524 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
525 return nil, errors.New("field of type String does not have child fields")
526 },
527 }
528 return fc, nil
529}
530
531func (ec *executionContext) _BugCreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
532 fc, err := ec.fieldContext_BugCreateOperation_files(ctx, field)
533 if err != nil {
534 return graphql.Null
535 }
536 ctx = graphql.WithFieldContext(ctx, fc)
537 defer func() {
538 if r := recover(); r != nil {
539 ec.Error(ctx, ec.Recover(ctx, r))
540 ret = graphql.Null
541 }
542 }()
543 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
544 ctx = rctx // use context from middleware stack in children
545 return obj.Files, nil
546 })
547 if err != nil {
548 ec.Error(ctx, err)
549 return graphql.Null
550 }
551 if resTmp == nil {
552 if !graphql.HasFieldError(ctx, fc) {
553 ec.Errorf(ctx, "must not be null")
554 }
555 return graphql.Null
556 }
557 res := resTmp.([]repository.Hash)
558 fc.Result = res
559 return ec.marshalNHash2ágithubácomágitábugágitábugárepositoryáHashá(ctx, field.Selections, res)
560}
561
562func (ec *executionContext) fieldContext_BugCreateOperation_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
563 fc = &graphql.FieldContext{
564 Object: "BugCreateOperation",
565 Field: field,
566 IsMethod: false,
567 IsResolver: false,
568 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
569 return nil, errors.New("field of type Hash does not have child fields")
570 },
571 }
572 return fc, nil
573}
574
575func (ec *executionContext) _BugEditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
576 fc, err := ec.fieldContext_BugEditCommentOperation_id(ctx, field)
577 if err != nil {
578 return graphql.Null
579 }
580 ctx = graphql.WithFieldContext(ctx, fc)
581 defer func() {
582 if r := recover(); r != nil {
583 ec.Error(ctx, ec.Recover(ctx, r))
584 ret = graphql.Null
585 }
586 }()
587 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
588 ctx = rctx // use context from middleware stack in children
589 return obj.Id(), nil
590 })
591 if err != nil {
592 ec.Error(ctx, err)
593 return graphql.Null
594 }
595 if resTmp == nil {
596 if !graphql.HasFieldError(ctx, fc) {
597 ec.Errorf(ctx, "must not be null")
598 }
599 return graphql.Null
600 }
601 res := resTmp.(entity.Id)
602 fc.Result = res
603 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
604}
605
606func (ec *executionContext) fieldContext_BugEditCommentOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
607 fc = &graphql.FieldContext{
608 Object: "BugEditCommentOperation",
609 Field: field,
610 IsMethod: true,
611 IsResolver: false,
612 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
613 return nil, errors.New("field of type ID does not have child fields")
614 },
615 }
616 return fc, nil
617}
618
619func (ec *executionContext) _BugEditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
620 fc, err := ec.fieldContext_BugEditCommentOperation_author(ctx, field)
621 if err != nil {
622 return graphql.Null
623 }
624 ctx = graphql.WithFieldContext(ctx, fc)
625 defer func() {
626 if r := recover(); r != nil {
627 ec.Error(ctx, ec.Recover(ctx, r))
628 ret = graphql.Null
629 }
630 }()
631 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
632 ctx = rctx // use context from middleware stack in children
633 return ec.resolvers.BugEditCommentOperation().Author(rctx, obj)
634 })
635 if err != nil {
636 ec.Error(ctx, err)
637 return graphql.Null
638 }
639 if resTmp == nil {
640 if !graphql.HasFieldError(ctx, fc) {
641 ec.Errorf(ctx, "must not be null")
642 }
643 return graphql.Null
644 }
645 res := resTmp.(models.IdentityWrapper)
646 fc.Result = res
647 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
648}
649
650func (ec *executionContext) fieldContext_BugEditCommentOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
651 fc = &graphql.FieldContext{
652 Object: "BugEditCommentOperation",
653 Field: field,
654 IsMethod: true,
655 IsResolver: true,
656 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
657 switch field.Name {
658 case "id":
659 return ec.fieldContext_Identity_id(ctx, field)
660 case "humanId":
661 return ec.fieldContext_Identity_humanId(ctx, field)
662 case "name":
663 return ec.fieldContext_Identity_name(ctx, field)
664 case "email":
665 return ec.fieldContext_Identity_email(ctx, field)
666 case "login":
667 return ec.fieldContext_Identity_login(ctx, field)
668 case "displayName":
669 return ec.fieldContext_Identity_displayName(ctx, field)
670 case "avatarUrl":
671 return ec.fieldContext_Identity_avatarUrl(ctx, field)
672 case "isProtected":
673 return ec.fieldContext_Identity_isProtected(ctx, field)
674 }
675 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
676 },
677 }
678 return fc, nil
679}
680
681func (ec *executionContext) _BugEditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
682 fc, err := ec.fieldContext_BugEditCommentOperation_date(ctx, field)
683 if err != nil {
684 return graphql.Null
685 }
686 ctx = graphql.WithFieldContext(ctx, fc)
687 defer func() {
688 if r := recover(); r != nil {
689 ec.Error(ctx, ec.Recover(ctx, r))
690 ret = graphql.Null
691 }
692 }()
693 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
694 ctx = rctx // use context from middleware stack in children
695 return obj.Time(), nil
696 })
697 if err != nil {
698 ec.Error(ctx, err)
699 return graphql.Null
700 }
701 if resTmp == nil {
702 if !graphql.HasFieldError(ctx, fc) {
703 ec.Errorf(ctx, "must not be null")
704 }
705 return graphql.Null
706 }
707 res := resTmp.(time.Time)
708 fc.Result = res
709 return ec.marshalNTime2timeáTime(ctx, field.Selections, res)
710}
711
712func (ec *executionContext) fieldContext_BugEditCommentOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
713 fc = &graphql.FieldContext{
714 Object: "BugEditCommentOperation",
715 Field: field,
716 IsMethod: true,
717 IsResolver: false,
718 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
719 return nil, errors.New("field of type Time does not have child fields")
720 },
721 }
722 return fc, nil
723}
724
725func (ec *executionContext) _BugEditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
726 fc, err := ec.fieldContext_BugEditCommentOperation_target(ctx, field)
727 if err != nil {
728 return graphql.Null
729 }
730 ctx = graphql.WithFieldContext(ctx, fc)
731 defer func() {
732 if r := recover(); r != nil {
733 ec.Error(ctx, ec.Recover(ctx, r))
734 ret = graphql.Null
735 }
736 }()
737 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
738 ctx = rctx // use context from middleware stack in children
739 return obj.Target, nil
740 })
741 if err != nil {
742 ec.Error(ctx, err)
743 return graphql.Null
744 }
745 if resTmp == nil {
746 if !graphql.HasFieldError(ctx, fc) {
747 ec.Errorf(ctx, "must not be null")
748 }
749 return graphql.Null
750 }
751 res := resTmp.(entity.Id)
752 fc.Result = res
753 return ec.marshalNString2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
754}
755
756func (ec *executionContext) fieldContext_BugEditCommentOperation_target(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
757 fc = &graphql.FieldContext{
758 Object: "BugEditCommentOperation",
759 Field: field,
760 IsMethod: false,
761 IsResolver: false,
762 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
763 return nil, errors.New("field of type String does not have child fields")
764 },
765 }
766 return fc, nil
767}
768
769func (ec *executionContext) _BugEditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
770 fc, err := ec.fieldContext_BugEditCommentOperation_message(ctx, field)
771 if err != nil {
772 return graphql.Null
773 }
774 ctx = graphql.WithFieldContext(ctx, fc)
775 defer func() {
776 if r := recover(); r != nil {
777 ec.Error(ctx, ec.Recover(ctx, r))
778 ret = graphql.Null
779 }
780 }()
781 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
782 ctx = rctx // use context from middleware stack in children
783 return obj.Message, nil
784 })
785 if err != nil {
786 ec.Error(ctx, err)
787 return graphql.Null
788 }
789 if resTmp == nil {
790 if !graphql.HasFieldError(ctx, fc) {
791 ec.Errorf(ctx, "must not be null")
792 }
793 return graphql.Null
794 }
795 res := resTmp.(string)
796 fc.Result = res
797 return ec.marshalNString2string(ctx, field.Selections, res)
798}
799
800func (ec *executionContext) fieldContext_BugEditCommentOperation_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
801 fc = &graphql.FieldContext{
802 Object: "BugEditCommentOperation",
803 Field: field,
804 IsMethod: false,
805 IsResolver: false,
806 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
807 return nil, errors.New("field of type String does not have child fields")
808 },
809 }
810 return fc, nil
811}
812
813func (ec *executionContext) _BugEditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
814 fc, err := ec.fieldContext_BugEditCommentOperation_files(ctx, field)
815 if err != nil {
816 return graphql.Null
817 }
818 ctx = graphql.WithFieldContext(ctx, fc)
819 defer func() {
820 if r := recover(); r != nil {
821 ec.Error(ctx, ec.Recover(ctx, r))
822 ret = graphql.Null
823 }
824 }()
825 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
826 ctx = rctx // use context from middleware stack in children
827 return obj.Files, nil
828 })
829 if err != nil {
830 ec.Error(ctx, err)
831 return graphql.Null
832 }
833 if resTmp == nil {
834 if !graphql.HasFieldError(ctx, fc) {
835 ec.Errorf(ctx, "must not be null")
836 }
837 return graphql.Null
838 }
839 res := resTmp.([]repository.Hash)
840 fc.Result = res
841 return ec.marshalNHash2ágithubácomágitábugágitábugárepositoryáHashá(ctx, field.Selections, res)
842}
843
844func (ec *executionContext) fieldContext_BugEditCommentOperation_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
845 fc = &graphql.FieldContext{
846 Object: "BugEditCommentOperation",
847 Field: field,
848 IsMethod: false,
849 IsResolver: false,
850 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
851 return nil, errors.New("field of type Hash does not have child fields")
852 },
853 }
854 return fc, nil
855}
856
857func (ec *executionContext) _BugLabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
858 fc, err := ec.fieldContext_BugLabelChangeOperation_id(ctx, field)
859 if err != nil {
860 return graphql.Null
861 }
862 ctx = graphql.WithFieldContext(ctx, fc)
863 defer func() {
864 if r := recover(); r != nil {
865 ec.Error(ctx, ec.Recover(ctx, r))
866 ret = graphql.Null
867 }
868 }()
869 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
870 ctx = rctx // use context from middleware stack in children
871 return obj.Id(), nil
872 })
873 if err != nil {
874 ec.Error(ctx, err)
875 return graphql.Null
876 }
877 if resTmp == nil {
878 if !graphql.HasFieldError(ctx, fc) {
879 ec.Errorf(ctx, "must not be null")
880 }
881 return graphql.Null
882 }
883 res := resTmp.(entity.Id)
884 fc.Result = res
885 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
886}
887
888func (ec *executionContext) fieldContext_BugLabelChangeOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
889 fc = &graphql.FieldContext{
890 Object: "BugLabelChangeOperation",
891 Field: field,
892 IsMethod: true,
893 IsResolver: false,
894 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
895 return nil, errors.New("field of type ID does not have child fields")
896 },
897 }
898 return fc, nil
899}
900
901func (ec *executionContext) _BugLabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
902 fc, err := ec.fieldContext_BugLabelChangeOperation_author(ctx, field)
903 if err != nil {
904 return graphql.Null
905 }
906 ctx = graphql.WithFieldContext(ctx, fc)
907 defer func() {
908 if r := recover(); r != nil {
909 ec.Error(ctx, ec.Recover(ctx, r))
910 ret = graphql.Null
911 }
912 }()
913 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
914 ctx = rctx // use context from middleware stack in children
915 return ec.resolvers.BugLabelChangeOperation().Author(rctx, obj)
916 })
917 if err != nil {
918 ec.Error(ctx, err)
919 return graphql.Null
920 }
921 if resTmp == nil {
922 if !graphql.HasFieldError(ctx, fc) {
923 ec.Errorf(ctx, "must not be null")
924 }
925 return graphql.Null
926 }
927 res := resTmp.(models.IdentityWrapper)
928 fc.Result = res
929 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
930}
931
932func (ec *executionContext) fieldContext_BugLabelChangeOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
933 fc = &graphql.FieldContext{
934 Object: "BugLabelChangeOperation",
935 Field: field,
936 IsMethod: true,
937 IsResolver: true,
938 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
939 switch field.Name {
940 case "id":
941 return ec.fieldContext_Identity_id(ctx, field)
942 case "humanId":
943 return ec.fieldContext_Identity_humanId(ctx, field)
944 case "name":
945 return ec.fieldContext_Identity_name(ctx, field)
946 case "email":
947 return ec.fieldContext_Identity_email(ctx, field)
948 case "login":
949 return ec.fieldContext_Identity_login(ctx, field)
950 case "displayName":
951 return ec.fieldContext_Identity_displayName(ctx, field)
952 case "avatarUrl":
953 return ec.fieldContext_Identity_avatarUrl(ctx, field)
954 case "isProtected":
955 return ec.fieldContext_Identity_isProtected(ctx, field)
956 }
957 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
958 },
959 }
960 return fc, nil
961}
962
963func (ec *executionContext) _BugLabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
964 fc, err := ec.fieldContext_BugLabelChangeOperation_date(ctx, field)
965 if err != nil {
966 return graphql.Null
967 }
968 ctx = graphql.WithFieldContext(ctx, fc)
969 defer func() {
970 if r := recover(); r != nil {
971 ec.Error(ctx, ec.Recover(ctx, r))
972 ret = graphql.Null
973 }
974 }()
975 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
976 ctx = rctx // use context from middleware stack in children
977 return obj.Time(), nil
978 })
979 if err != nil {
980 ec.Error(ctx, err)
981 return graphql.Null
982 }
983 if resTmp == nil {
984 if !graphql.HasFieldError(ctx, fc) {
985 ec.Errorf(ctx, "must not be null")
986 }
987 return graphql.Null
988 }
989 res := resTmp.(time.Time)
990 fc.Result = res
991 return ec.marshalNTime2timeáTime(ctx, field.Selections, res)
992}
993
994func (ec *executionContext) fieldContext_BugLabelChangeOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
995 fc = &graphql.FieldContext{
996 Object: "BugLabelChangeOperation",
997 Field: field,
998 IsMethod: true,
999 IsResolver: false,
1000 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1001 return nil, errors.New("field of type Time does not have child fields")
1002 },
1003 }
1004 return fc, nil
1005}
1006
1007func (ec *executionContext) _BugLabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
1008 fc, err := ec.fieldContext_BugLabelChangeOperation_added(ctx, field)
1009 if err != nil {
1010 return graphql.Null
1011 }
1012 ctx = graphql.WithFieldContext(ctx, fc)
1013 defer func() {
1014 if r := recover(); r != nil {
1015 ec.Error(ctx, ec.Recover(ctx, r))
1016 ret = graphql.Null
1017 }
1018 }()
1019 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1020 ctx = rctx // use context from middleware stack in children
1021 return obj.Added, nil
1022 })
1023 if err != nil {
1024 ec.Error(ctx, err)
1025 return graphql.Null
1026 }
1027 if resTmp == nil {
1028 if !graphql.HasFieldError(ctx, fc) {
1029 ec.Errorf(ctx, "must not be null")
1030 }
1031 return graphql.Null
1032 }
1033 res := resTmp.([]common.Label)
1034 fc.Result = res
1035 return ec.marshalNLabel2ágithubácomágitábugágitábugáentitiesácommonáLabelá(ctx, field.Selections, res)
1036}
1037
1038func (ec *executionContext) fieldContext_BugLabelChangeOperation_added(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1039 fc = &graphql.FieldContext{
1040 Object: "BugLabelChangeOperation",
1041 Field: field,
1042 IsMethod: false,
1043 IsResolver: false,
1044 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1045 switch field.Name {
1046 case "name":
1047 return ec.fieldContext_Label_name(ctx, field)
1048 case "color":
1049 return ec.fieldContext_Label_color(ctx, field)
1050 }
1051 return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
1052 },
1053 }
1054 return fc, nil
1055}
1056
1057func (ec *executionContext) _BugLabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
1058 fc, err := ec.fieldContext_BugLabelChangeOperation_removed(ctx, field)
1059 if err != nil {
1060 return graphql.Null
1061 }
1062 ctx = graphql.WithFieldContext(ctx, fc)
1063 defer func() {
1064 if r := recover(); r != nil {
1065 ec.Error(ctx, ec.Recover(ctx, r))
1066 ret = graphql.Null
1067 }
1068 }()
1069 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1070 ctx = rctx // use context from middleware stack in children
1071 return obj.Removed, nil
1072 })
1073 if err != nil {
1074 ec.Error(ctx, err)
1075 return graphql.Null
1076 }
1077 if resTmp == nil {
1078 if !graphql.HasFieldError(ctx, fc) {
1079 ec.Errorf(ctx, "must not be null")
1080 }
1081 return graphql.Null
1082 }
1083 res := resTmp.([]common.Label)
1084 fc.Result = res
1085 return ec.marshalNLabel2ágithubácomágitábugágitábugáentitiesácommonáLabelá(ctx, field.Selections, res)
1086}
1087
1088func (ec *executionContext) fieldContext_BugLabelChangeOperation_removed(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1089 fc = &graphql.FieldContext{
1090 Object: "BugLabelChangeOperation",
1091 Field: field,
1092 IsMethod: false,
1093 IsResolver: false,
1094 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1095 switch field.Name {
1096 case "name":
1097 return ec.fieldContext_Label_name(ctx, field)
1098 case "color":
1099 return ec.fieldContext_Label_color(ctx, field)
1100 }
1101 return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
1102 },
1103 }
1104 return fc, nil
1105}
1106
1107func (ec *executionContext) _BugSetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
1108 fc, err := ec.fieldContext_BugSetStatusOperation_id(ctx, field)
1109 if err != nil {
1110 return graphql.Null
1111 }
1112 ctx = graphql.WithFieldContext(ctx, fc)
1113 defer func() {
1114 if r := recover(); r != nil {
1115 ec.Error(ctx, ec.Recover(ctx, r))
1116 ret = graphql.Null
1117 }
1118 }()
1119 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1120 ctx = rctx // use context from middleware stack in children
1121 return obj.Id(), nil
1122 })
1123 if err != nil {
1124 ec.Error(ctx, err)
1125 return graphql.Null
1126 }
1127 if resTmp == nil {
1128 if !graphql.HasFieldError(ctx, fc) {
1129 ec.Errorf(ctx, "must not be null")
1130 }
1131 return graphql.Null
1132 }
1133 res := resTmp.(entity.Id)
1134 fc.Result = res
1135 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
1136}
1137
1138func (ec *executionContext) fieldContext_BugSetStatusOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1139 fc = &graphql.FieldContext{
1140 Object: "BugSetStatusOperation",
1141 Field: field,
1142 IsMethod: true,
1143 IsResolver: false,
1144 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1145 return nil, errors.New("field of type ID does not have child fields")
1146 },
1147 }
1148 return fc, nil
1149}
1150
1151func (ec *executionContext) _BugSetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
1152 fc, err := ec.fieldContext_BugSetStatusOperation_author(ctx, field)
1153 if err != nil {
1154 return graphql.Null
1155 }
1156 ctx = graphql.WithFieldContext(ctx, fc)
1157 defer func() {
1158 if r := recover(); r != nil {
1159 ec.Error(ctx, ec.Recover(ctx, r))
1160 ret = graphql.Null
1161 }
1162 }()
1163 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1164 ctx = rctx // use context from middleware stack in children
1165 return ec.resolvers.BugSetStatusOperation().Author(rctx, obj)
1166 })
1167 if err != nil {
1168 ec.Error(ctx, err)
1169 return graphql.Null
1170 }
1171 if resTmp == nil {
1172 if !graphql.HasFieldError(ctx, fc) {
1173 ec.Errorf(ctx, "must not be null")
1174 }
1175 return graphql.Null
1176 }
1177 res := resTmp.(models.IdentityWrapper)
1178 fc.Result = res
1179 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
1180}
1181
1182func (ec *executionContext) fieldContext_BugSetStatusOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1183 fc = &graphql.FieldContext{
1184 Object: "BugSetStatusOperation",
1185 Field: field,
1186 IsMethod: true,
1187 IsResolver: true,
1188 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1189 switch field.Name {
1190 case "id":
1191 return ec.fieldContext_Identity_id(ctx, field)
1192 case "humanId":
1193 return ec.fieldContext_Identity_humanId(ctx, field)
1194 case "name":
1195 return ec.fieldContext_Identity_name(ctx, field)
1196 case "email":
1197 return ec.fieldContext_Identity_email(ctx, field)
1198 case "login":
1199 return ec.fieldContext_Identity_login(ctx, field)
1200 case "displayName":
1201 return ec.fieldContext_Identity_displayName(ctx, field)
1202 case "avatarUrl":
1203 return ec.fieldContext_Identity_avatarUrl(ctx, field)
1204 case "isProtected":
1205 return ec.fieldContext_Identity_isProtected(ctx, field)
1206 }
1207 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
1208 },
1209 }
1210 return fc, nil
1211}
1212
1213func (ec *executionContext) _BugSetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
1214 fc, err := ec.fieldContext_BugSetStatusOperation_date(ctx, field)
1215 if err != nil {
1216 return graphql.Null
1217 }
1218 ctx = graphql.WithFieldContext(ctx, fc)
1219 defer func() {
1220 if r := recover(); r != nil {
1221 ec.Error(ctx, ec.Recover(ctx, r))
1222 ret = graphql.Null
1223 }
1224 }()
1225 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1226 ctx = rctx // use context from middleware stack in children
1227 return obj.Time(), nil
1228 })
1229 if err != nil {
1230 ec.Error(ctx, err)
1231 return graphql.Null
1232 }
1233 if resTmp == nil {
1234 if !graphql.HasFieldError(ctx, fc) {
1235 ec.Errorf(ctx, "must not be null")
1236 }
1237 return graphql.Null
1238 }
1239 res := resTmp.(time.Time)
1240 fc.Result = res
1241 return ec.marshalNTime2timeáTime(ctx, field.Selections, res)
1242}
1243
1244func (ec *executionContext) fieldContext_BugSetStatusOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1245 fc = &graphql.FieldContext{
1246 Object: "BugSetStatusOperation",
1247 Field: field,
1248 IsMethod: true,
1249 IsResolver: false,
1250 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1251 return nil, errors.New("field of type Time does not have child fields")
1252 },
1253 }
1254 return fc, nil
1255}
1256
1257func (ec *executionContext) _BugSetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
1258 fc, err := ec.fieldContext_BugSetStatusOperation_status(ctx, field)
1259 if err != nil {
1260 return graphql.Null
1261 }
1262 ctx = graphql.WithFieldContext(ctx, fc)
1263 defer func() {
1264 if r := recover(); r != nil {
1265 ec.Error(ctx, ec.Recover(ctx, r))
1266 ret = graphql.Null
1267 }
1268 }()
1269 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1270 ctx = rctx // use context from middleware stack in children
1271 return obj.Status, nil
1272 })
1273 if err != nil {
1274 ec.Error(ctx, err)
1275 return graphql.Null
1276 }
1277 if resTmp == nil {
1278 if !graphql.HasFieldError(ctx, fc) {
1279 ec.Errorf(ctx, "must not be null")
1280 }
1281 return graphql.Null
1282 }
1283 res := resTmp.(common.Status)
1284 fc.Result = res
1285 return ec.marshalNStatus2githubácomágitábugágitábugáentitiesácommonáStatus(ctx, field.Selections, res)
1286}
1287
1288func (ec *executionContext) fieldContext_BugSetStatusOperation_status(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1289 fc = &graphql.FieldContext{
1290 Object: "BugSetStatusOperation",
1291 Field: field,
1292 IsMethod: false,
1293 IsResolver: false,
1294 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1295 return nil, errors.New("field of type Status does not have child fields")
1296 },
1297 }
1298 return fc, nil
1299}
1300
1301func (ec *executionContext) _BugSetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
1302 fc, err := ec.fieldContext_BugSetTitleOperation_id(ctx, field)
1303 if err != nil {
1304 return graphql.Null
1305 }
1306 ctx = graphql.WithFieldContext(ctx, fc)
1307 defer func() {
1308 if r := recover(); r != nil {
1309 ec.Error(ctx, ec.Recover(ctx, r))
1310 ret = graphql.Null
1311 }
1312 }()
1313 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1314 ctx = rctx // use context from middleware stack in children
1315 return obj.Id(), nil
1316 })
1317 if err != nil {
1318 ec.Error(ctx, err)
1319 return graphql.Null
1320 }
1321 if resTmp == nil {
1322 if !graphql.HasFieldError(ctx, fc) {
1323 ec.Errorf(ctx, "must not be null")
1324 }
1325 return graphql.Null
1326 }
1327 res := resTmp.(entity.Id)
1328 fc.Result = res
1329 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
1330}
1331
1332func (ec *executionContext) fieldContext_BugSetTitleOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1333 fc = &graphql.FieldContext{
1334 Object: "BugSetTitleOperation",
1335 Field: field,
1336 IsMethod: true,
1337 IsResolver: false,
1338 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1339 return nil, errors.New("field of type ID does not have child fields")
1340 },
1341 }
1342 return fc, nil
1343}
1344
1345func (ec *executionContext) _BugSetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
1346 fc, err := ec.fieldContext_BugSetTitleOperation_author(ctx, field)
1347 if err != nil {
1348 return graphql.Null
1349 }
1350 ctx = graphql.WithFieldContext(ctx, fc)
1351 defer func() {
1352 if r := recover(); r != nil {
1353 ec.Error(ctx, ec.Recover(ctx, r))
1354 ret = graphql.Null
1355 }
1356 }()
1357 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1358 ctx = rctx // use context from middleware stack in children
1359 return ec.resolvers.BugSetTitleOperation().Author(rctx, obj)
1360 })
1361 if err != nil {
1362 ec.Error(ctx, err)
1363 return graphql.Null
1364 }
1365 if resTmp == nil {
1366 if !graphql.HasFieldError(ctx, fc) {
1367 ec.Errorf(ctx, "must not be null")
1368 }
1369 return graphql.Null
1370 }
1371 res := resTmp.(models.IdentityWrapper)
1372 fc.Result = res
1373 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
1374}
1375
1376func (ec *executionContext) fieldContext_BugSetTitleOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1377 fc = &graphql.FieldContext{
1378 Object: "BugSetTitleOperation",
1379 Field: field,
1380 IsMethod: true,
1381 IsResolver: true,
1382 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1383 switch field.Name {
1384 case "id":
1385 return ec.fieldContext_Identity_id(ctx, field)
1386 case "humanId":
1387 return ec.fieldContext_Identity_humanId(ctx, field)
1388 case "name":
1389 return ec.fieldContext_Identity_name(ctx, field)
1390 case "email":
1391 return ec.fieldContext_Identity_email(ctx, field)
1392 case "login":
1393 return ec.fieldContext_Identity_login(ctx, field)
1394 case "displayName":
1395 return ec.fieldContext_Identity_displayName(ctx, field)
1396 case "avatarUrl":
1397 return ec.fieldContext_Identity_avatarUrl(ctx, field)
1398 case "isProtected":
1399 return ec.fieldContext_Identity_isProtected(ctx, field)
1400 }
1401 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
1402 },
1403 }
1404 return fc, nil
1405}
1406
1407func (ec *executionContext) _BugSetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
1408 fc, err := ec.fieldContext_BugSetTitleOperation_date(ctx, field)
1409 if err != nil {
1410 return graphql.Null
1411 }
1412 ctx = graphql.WithFieldContext(ctx, fc)
1413 defer func() {
1414 if r := recover(); r != nil {
1415 ec.Error(ctx, ec.Recover(ctx, r))
1416 ret = graphql.Null
1417 }
1418 }()
1419 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1420 ctx = rctx // use context from middleware stack in children
1421 return obj.Time(), nil
1422 })
1423 if err != nil {
1424 ec.Error(ctx, err)
1425 return graphql.Null
1426 }
1427 if resTmp == nil {
1428 if !graphql.HasFieldError(ctx, fc) {
1429 ec.Errorf(ctx, "must not be null")
1430 }
1431 return graphql.Null
1432 }
1433 res := resTmp.(time.Time)
1434 fc.Result = res
1435 return ec.marshalNTime2timeáTime(ctx, field.Selections, res)
1436}
1437
1438func (ec *executionContext) fieldContext_BugSetTitleOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1439 fc = &graphql.FieldContext{
1440 Object: "BugSetTitleOperation",
1441 Field: field,
1442 IsMethod: true,
1443 IsResolver: false,
1444 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1445 return nil, errors.New("field of type Time does not have child fields")
1446 },
1447 }
1448 return fc, nil
1449}
1450
1451func (ec *executionContext) _BugSetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
1452 fc, err := ec.fieldContext_BugSetTitleOperation_title(ctx, field)
1453 if err != nil {
1454 return graphql.Null
1455 }
1456 ctx = graphql.WithFieldContext(ctx, fc)
1457 defer func() {
1458 if r := recover(); r != nil {
1459 ec.Error(ctx, ec.Recover(ctx, r))
1460 ret = graphql.Null
1461 }
1462 }()
1463 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1464 ctx = rctx // use context from middleware stack in children
1465 return obj.Title, nil
1466 })
1467 if err != nil {
1468 ec.Error(ctx, err)
1469 return graphql.Null
1470 }
1471 if resTmp == nil {
1472 if !graphql.HasFieldError(ctx, fc) {
1473 ec.Errorf(ctx, "must not be null")
1474 }
1475 return graphql.Null
1476 }
1477 res := resTmp.(string)
1478 fc.Result = res
1479 return ec.marshalNString2string(ctx, field.Selections, res)
1480}
1481
1482func (ec *executionContext) fieldContext_BugSetTitleOperation_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1483 fc = &graphql.FieldContext{
1484 Object: "BugSetTitleOperation",
1485 Field: field,
1486 IsMethod: false,
1487 IsResolver: false,
1488 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1489 return nil, errors.New("field of type String does not have child fields")
1490 },
1491 }
1492 return fc, nil
1493}
1494
1495func (ec *executionContext) _BugSetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
1496 fc, err := ec.fieldContext_BugSetTitleOperation_was(ctx, field)
1497 if err != nil {
1498 return graphql.Null
1499 }
1500 ctx = graphql.WithFieldContext(ctx, fc)
1501 defer func() {
1502 if r := recover(); r != nil {
1503 ec.Error(ctx, ec.Recover(ctx, r))
1504 ret = graphql.Null
1505 }
1506 }()
1507 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1508 ctx = rctx // use context from middleware stack in children
1509 return obj.Was, nil
1510 })
1511 if err != nil {
1512 ec.Error(ctx, err)
1513 return graphql.Null
1514 }
1515 if resTmp == nil {
1516 if !graphql.HasFieldError(ctx, fc) {
1517 ec.Errorf(ctx, "must not be null")
1518 }
1519 return graphql.Null
1520 }
1521 res := resTmp.(string)
1522 fc.Result = res
1523 return ec.marshalNString2string(ctx, field.Selections, res)
1524}
1525
1526func (ec *executionContext) fieldContext_BugSetTitleOperation_was(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1527 fc = &graphql.FieldContext{
1528 Object: "BugSetTitleOperation",
1529 Field: field,
1530 IsMethod: false,
1531 IsResolver: false,
1532 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1533 return nil, errors.New("field of type String does not have child fields")
1534 },
1535 }
1536 return fc, nil
1537}
1538
1539// endregion **************************** field.gotpl *****************************
1540
1541// region **************************** input.gotpl *****************************
1542
1543// endregion **************************** input.gotpl *****************************
1544
1545// region ************************** interface.gotpl ***************************
1546
1547// endregion ************************** interface.gotpl ***************************
1548
1549// region **************************** object.gotpl ****************************
1550
1551var bugAddCommentOperationImplementors = []string{"BugAddCommentOperation", "Operation", "Authored"}
1552
1553func (ec *executionContext) _BugAddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
1554 fields := graphql.CollectFields(ec.OperationContext, sel, bugAddCommentOperationImplementors)
1555
1556 out := graphql.NewFieldSet(fields)
1557 deferred := make(map[string]*graphql.FieldSet)
1558 for i, field := range fields {
1559 switch field.Name {
1560 case "__typename":
1561 out.Values[i] = graphql.MarshalString("BugAddCommentOperation")
1562 case "id":
1563 out.Values[i] = ec._BugAddCommentOperation_id(ctx, field, obj)
1564 if out.Values[i] == graphql.Null {
1565 atomic.AddUint32(&out.Invalids, 1)
1566 }
1567 case "author":
1568 field := field
1569
1570 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1571 defer func() {
1572 if r := recover(); r != nil {
1573 ec.Error(ctx, ec.Recover(ctx, r))
1574 }
1575 }()
1576 res = ec._BugAddCommentOperation_author(ctx, field, obj)
1577 if res == graphql.Null {
1578 atomic.AddUint32(&fs.Invalids, 1)
1579 }
1580 return res
1581 }
1582
1583 if field.Deferrable != nil {
1584 dfs, ok := deferred[field.Deferrable.Label]
1585 di := 0
1586 if ok {
1587 dfs.AddField(field)
1588 di = len(dfs.Values) - 1
1589 } else {
1590 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1591 deferred[field.Deferrable.Label] = dfs
1592 }
1593 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1594 return innerFunc(ctx, dfs)
1595 })
1596
1597 // don't run the out.Concurrently() call below
1598 out.Values[i] = graphql.Null
1599 continue
1600 }
1601
1602 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1603 case "date":
1604 out.Values[i] = ec._BugAddCommentOperation_date(ctx, field, obj)
1605 if out.Values[i] == graphql.Null {
1606 atomic.AddUint32(&out.Invalids, 1)
1607 }
1608 case "message":
1609 out.Values[i] = ec._BugAddCommentOperation_message(ctx, field, obj)
1610 if out.Values[i] == graphql.Null {
1611 atomic.AddUint32(&out.Invalids, 1)
1612 }
1613 case "files":
1614 out.Values[i] = ec._BugAddCommentOperation_files(ctx, field, obj)
1615 if out.Values[i] == graphql.Null {
1616 atomic.AddUint32(&out.Invalids, 1)
1617 }
1618 default:
1619 panic("unknown field " + strconv.Quote(field.Name))
1620 }
1621 }
1622 out.Dispatch(ctx)
1623 if out.Invalids > 0 {
1624 return graphql.Null
1625 }
1626
1627 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1628
1629 for label, dfs := range deferred {
1630 ec.processDeferredGroup(graphql.DeferredGroup{
1631 Label: label,
1632 Path: graphql.GetPath(ctx),
1633 FieldSet: dfs,
1634 Context: ctx,
1635 })
1636 }
1637
1638 return out
1639}
1640
1641var bugCreateOperationImplementors = []string{"BugCreateOperation", "Operation", "Authored"}
1642
1643func (ec *executionContext) _BugCreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
1644 fields := graphql.CollectFields(ec.OperationContext, sel, bugCreateOperationImplementors)
1645
1646 out := graphql.NewFieldSet(fields)
1647 deferred := make(map[string]*graphql.FieldSet)
1648 for i, field := range fields {
1649 switch field.Name {
1650 case "__typename":
1651 out.Values[i] = graphql.MarshalString("BugCreateOperation")
1652 case "id":
1653 out.Values[i] = ec._BugCreateOperation_id(ctx, field, obj)
1654 if out.Values[i] == graphql.Null {
1655 atomic.AddUint32(&out.Invalids, 1)
1656 }
1657 case "author":
1658 field := field
1659
1660 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1661 defer func() {
1662 if r := recover(); r != nil {
1663 ec.Error(ctx, ec.Recover(ctx, r))
1664 }
1665 }()
1666 res = ec._BugCreateOperation_author(ctx, field, obj)
1667 if res == graphql.Null {
1668 atomic.AddUint32(&fs.Invalids, 1)
1669 }
1670 return res
1671 }
1672
1673 if field.Deferrable != nil {
1674 dfs, ok := deferred[field.Deferrable.Label]
1675 di := 0
1676 if ok {
1677 dfs.AddField(field)
1678 di = len(dfs.Values) - 1
1679 } else {
1680 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1681 deferred[field.Deferrable.Label] = dfs
1682 }
1683 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1684 return innerFunc(ctx, dfs)
1685 })
1686
1687 // don't run the out.Concurrently() call below
1688 out.Values[i] = graphql.Null
1689 continue
1690 }
1691
1692 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1693 case "date":
1694 out.Values[i] = ec._BugCreateOperation_date(ctx, field, obj)
1695 if out.Values[i] == graphql.Null {
1696 atomic.AddUint32(&out.Invalids, 1)
1697 }
1698 case "title":
1699 out.Values[i] = ec._BugCreateOperation_title(ctx, field, obj)
1700 if out.Values[i] == graphql.Null {
1701 atomic.AddUint32(&out.Invalids, 1)
1702 }
1703 case "message":
1704 out.Values[i] = ec._BugCreateOperation_message(ctx, field, obj)
1705 if out.Values[i] == graphql.Null {
1706 atomic.AddUint32(&out.Invalids, 1)
1707 }
1708 case "files":
1709 out.Values[i] = ec._BugCreateOperation_files(ctx, field, obj)
1710 if out.Values[i] == graphql.Null {
1711 atomic.AddUint32(&out.Invalids, 1)
1712 }
1713 default:
1714 panic("unknown field " + strconv.Quote(field.Name))
1715 }
1716 }
1717 out.Dispatch(ctx)
1718 if out.Invalids > 0 {
1719 return graphql.Null
1720 }
1721
1722 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1723
1724 for label, dfs := range deferred {
1725 ec.processDeferredGroup(graphql.DeferredGroup{
1726 Label: label,
1727 Path: graphql.GetPath(ctx),
1728 FieldSet: dfs,
1729 Context: ctx,
1730 })
1731 }
1732
1733 return out
1734}
1735
1736var bugEditCommentOperationImplementors = []string{"BugEditCommentOperation", "Operation", "Authored"}
1737
1738func (ec *executionContext) _BugEditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
1739 fields := graphql.CollectFields(ec.OperationContext, sel, bugEditCommentOperationImplementors)
1740
1741 out := graphql.NewFieldSet(fields)
1742 deferred := make(map[string]*graphql.FieldSet)
1743 for i, field := range fields {
1744 switch field.Name {
1745 case "__typename":
1746 out.Values[i] = graphql.MarshalString("BugEditCommentOperation")
1747 case "id":
1748 out.Values[i] = ec._BugEditCommentOperation_id(ctx, field, obj)
1749 if out.Values[i] == graphql.Null {
1750 atomic.AddUint32(&out.Invalids, 1)
1751 }
1752 case "author":
1753 field := field
1754
1755 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1756 defer func() {
1757 if r := recover(); r != nil {
1758 ec.Error(ctx, ec.Recover(ctx, r))
1759 }
1760 }()
1761 res = ec._BugEditCommentOperation_author(ctx, field, obj)
1762 if res == graphql.Null {
1763 atomic.AddUint32(&fs.Invalids, 1)
1764 }
1765 return res
1766 }
1767
1768 if field.Deferrable != nil {
1769 dfs, ok := deferred[field.Deferrable.Label]
1770 di := 0
1771 if ok {
1772 dfs.AddField(field)
1773 di = len(dfs.Values) - 1
1774 } else {
1775 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1776 deferred[field.Deferrable.Label] = dfs
1777 }
1778 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1779 return innerFunc(ctx, dfs)
1780 })
1781
1782 // don't run the out.Concurrently() call below
1783 out.Values[i] = graphql.Null
1784 continue
1785 }
1786
1787 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1788 case "date":
1789 out.Values[i] = ec._BugEditCommentOperation_date(ctx, field, obj)
1790 if out.Values[i] == graphql.Null {
1791 atomic.AddUint32(&out.Invalids, 1)
1792 }
1793 case "target":
1794 out.Values[i] = ec._BugEditCommentOperation_target(ctx, field, obj)
1795 if out.Values[i] == graphql.Null {
1796 atomic.AddUint32(&out.Invalids, 1)
1797 }
1798 case "message":
1799 out.Values[i] = ec._BugEditCommentOperation_message(ctx, field, obj)
1800 if out.Values[i] == graphql.Null {
1801 atomic.AddUint32(&out.Invalids, 1)
1802 }
1803 case "files":
1804 out.Values[i] = ec._BugEditCommentOperation_files(ctx, field, obj)
1805 if out.Values[i] == graphql.Null {
1806 atomic.AddUint32(&out.Invalids, 1)
1807 }
1808 default:
1809 panic("unknown field " + strconv.Quote(field.Name))
1810 }
1811 }
1812 out.Dispatch(ctx)
1813 if out.Invalids > 0 {
1814 return graphql.Null
1815 }
1816
1817 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1818
1819 for label, dfs := range deferred {
1820 ec.processDeferredGroup(graphql.DeferredGroup{
1821 Label: label,
1822 Path: graphql.GetPath(ctx),
1823 FieldSet: dfs,
1824 Context: ctx,
1825 })
1826 }
1827
1828 return out
1829}
1830
1831var bugLabelChangeOperationImplementors = []string{"BugLabelChangeOperation", "Operation", "Authored"}
1832
1833func (ec *executionContext) _BugLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
1834 fields := graphql.CollectFields(ec.OperationContext, sel, bugLabelChangeOperationImplementors)
1835
1836 out := graphql.NewFieldSet(fields)
1837 deferred := make(map[string]*graphql.FieldSet)
1838 for i, field := range fields {
1839 switch field.Name {
1840 case "__typename":
1841 out.Values[i] = graphql.MarshalString("BugLabelChangeOperation")
1842 case "id":
1843 out.Values[i] = ec._BugLabelChangeOperation_id(ctx, field, obj)
1844 if out.Values[i] == graphql.Null {
1845 atomic.AddUint32(&out.Invalids, 1)
1846 }
1847 case "author":
1848 field := field
1849
1850 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1851 defer func() {
1852 if r := recover(); r != nil {
1853 ec.Error(ctx, ec.Recover(ctx, r))
1854 }
1855 }()
1856 res = ec._BugLabelChangeOperation_author(ctx, field, obj)
1857 if res == graphql.Null {
1858 atomic.AddUint32(&fs.Invalids, 1)
1859 }
1860 return res
1861 }
1862
1863 if field.Deferrable != nil {
1864 dfs, ok := deferred[field.Deferrable.Label]
1865 di := 0
1866 if ok {
1867 dfs.AddField(field)
1868 di = len(dfs.Values) - 1
1869 } else {
1870 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1871 deferred[field.Deferrable.Label] = dfs
1872 }
1873 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1874 return innerFunc(ctx, dfs)
1875 })
1876
1877 // don't run the out.Concurrently() call below
1878 out.Values[i] = graphql.Null
1879 continue
1880 }
1881
1882 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1883 case "date":
1884 out.Values[i] = ec._BugLabelChangeOperation_date(ctx, field, obj)
1885 if out.Values[i] == graphql.Null {
1886 atomic.AddUint32(&out.Invalids, 1)
1887 }
1888 case "added":
1889 out.Values[i] = ec._BugLabelChangeOperation_added(ctx, field, obj)
1890 if out.Values[i] == graphql.Null {
1891 atomic.AddUint32(&out.Invalids, 1)
1892 }
1893 case "removed":
1894 out.Values[i] = ec._BugLabelChangeOperation_removed(ctx, field, obj)
1895 if out.Values[i] == graphql.Null {
1896 atomic.AddUint32(&out.Invalids, 1)
1897 }
1898 default:
1899 panic("unknown field " + strconv.Quote(field.Name))
1900 }
1901 }
1902 out.Dispatch(ctx)
1903 if out.Invalids > 0 {
1904 return graphql.Null
1905 }
1906
1907 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1908
1909 for label, dfs := range deferred {
1910 ec.processDeferredGroup(graphql.DeferredGroup{
1911 Label: label,
1912 Path: graphql.GetPath(ctx),
1913 FieldSet: dfs,
1914 Context: ctx,
1915 })
1916 }
1917
1918 return out
1919}
1920
1921var bugSetStatusOperationImplementors = []string{"BugSetStatusOperation", "Operation", "Authored"}
1922
1923func (ec *executionContext) _BugSetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
1924 fields := graphql.CollectFields(ec.OperationContext, sel, bugSetStatusOperationImplementors)
1925
1926 out := graphql.NewFieldSet(fields)
1927 deferred := make(map[string]*graphql.FieldSet)
1928 for i, field := range fields {
1929 switch field.Name {
1930 case "__typename":
1931 out.Values[i] = graphql.MarshalString("BugSetStatusOperation")
1932 case "id":
1933 out.Values[i] = ec._BugSetStatusOperation_id(ctx, field, obj)
1934 if out.Values[i] == graphql.Null {
1935 atomic.AddUint32(&out.Invalids, 1)
1936 }
1937 case "author":
1938 field := field
1939
1940 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1941 defer func() {
1942 if r := recover(); r != nil {
1943 ec.Error(ctx, ec.Recover(ctx, r))
1944 }
1945 }()
1946 res = ec._BugSetStatusOperation_author(ctx, field, obj)
1947 if res == graphql.Null {
1948 atomic.AddUint32(&fs.Invalids, 1)
1949 }
1950 return res
1951 }
1952
1953 if field.Deferrable != nil {
1954 dfs, ok := deferred[field.Deferrable.Label]
1955 di := 0
1956 if ok {
1957 dfs.AddField(field)
1958 di = len(dfs.Values) - 1
1959 } else {
1960 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1961 deferred[field.Deferrable.Label] = dfs
1962 }
1963 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1964 return innerFunc(ctx, dfs)
1965 })
1966
1967 // don't run the out.Concurrently() call below
1968 out.Values[i] = graphql.Null
1969 continue
1970 }
1971
1972 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1973 case "date":
1974 out.Values[i] = ec._BugSetStatusOperation_date(ctx, field, obj)
1975 if out.Values[i] == graphql.Null {
1976 atomic.AddUint32(&out.Invalids, 1)
1977 }
1978 case "status":
1979 out.Values[i] = ec._BugSetStatusOperation_status(ctx, field, obj)
1980 if out.Values[i] == graphql.Null {
1981 atomic.AddUint32(&out.Invalids, 1)
1982 }
1983 default:
1984 panic("unknown field " + strconv.Quote(field.Name))
1985 }
1986 }
1987 out.Dispatch(ctx)
1988 if out.Invalids > 0 {
1989 return graphql.Null
1990 }
1991
1992 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1993
1994 for label, dfs := range deferred {
1995 ec.processDeferredGroup(graphql.DeferredGroup{
1996 Label: label,
1997 Path: graphql.GetPath(ctx),
1998 FieldSet: dfs,
1999 Context: ctx,
2000 })
2001 }
2002
2003 return out
2004}
2005
2006var bugSetTitleOperationImplementors = []string{"BugSetTitleOperation", "Operation", "Authored"}
2007
2008func (ec *executionContext) _BugSetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
2009 fields := graphql.CollectFields(ec.OperationContext, sel, bugSetTitleOperationImplementors)
2010
2011 out := graphql.NewFieldSet(fields)
2012 deferred := make(map[string]*graphql.FieldSet)
2013 for i, field := range fields {
2014 switch field.Name {
2015 case "__typename":
2016 out.Values[i] = graphql.MarshalString("BugSetTitleOperation")
2017 case "id":
2018 out.Values[i] = ec._BugSetTitleOperation_id(ctx, field, obj)
2019 if out.Values[i] == graphql.Null {
2020 atomic.AddUint32(&out.Invalids, 1)
2021 }
2022 case "author":
2023 field := field
2024
2025 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2026 defer func() {
2027 if r := recover(); r != nil {
2028 ec.Error(ctx, ec.Recover(ctx, r))
2029 }
2030 }()
2031 res = ec._BugSetTitleOperation_author(ctx, field, obj)
2032 if res == graphql.Null {
2033 atomic.AddUint32(&fs.Invalids, 1)
2034 }
2035 return res
2036 }
2037
2038 if field.Deferrable != nil {
2039 dfs, ok := deferred[field.Deferrable.Label]
2040 di := 0
2041 if ok {
2042 dfs.AddField(field)
2043 di = len(dfs.Values) - 1
2044 } else {
2045 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2046 deferred[field.Deferrable.Label] = dfs
2047 }
2048 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2049 return innerFunc(ctx, dfs)
2050 })
2051
2052 // don't run the out.Concurrently() call below
2053 out.Values[i] = graphql.Null
2054 continue
2055 }
2056
2057 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2058 case "date":
2059 out.Values[i] = ec._BugSetTitleOperation_date(ctx, field, obj)
2060 if out.Values[i] == graphql.Null {
2061 atomic.AddUint32(&out.Invalids, 1)
2062 }
2063 case "title":
2064 out.Values[i] = ec._BugSetTitleOperation_title(ctx, field, obj)
2065 if out.Values[i] == graphql.Null {
2066 atomic.AddUint32(&out.Invalids, 1)
2067 }
2068 case "was":
2069 out.Values[i] = ec._BugSetTitleOperation_was(ctx, field, obj)
2070 if out.Values[i] == graphql.Null {
2071 atomic.AddUint32(&out.Invalids, 1)
2072 }
2073 default:
2074 panic("unknown field " + strconv.Quote(field.Name))
2075 }
2076 }
2077 out.Dispatch(ctx)
2078 if out.Invalids > 0 {
2079 return graphql.Null
2080 }
2081
2082 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2083
2084 for label, dfs := range deferred {
2085 ec.processDeferredGroup(graphql.DeferredGroup{
2086 Label: label,
2087 Path: graphql.GetPath(ctx),
2088 FieldSet: dfs,
2089 Context: ctx,
2090 })
2091 }
2092
2093 return out
2094}
2095
2096// endregion **************************** object.gotpl ****************************
2097
2098// region ***************************** type.gotpl *****************************
2099
2100func (ec *executionContext) marshalNBugAddCommentOperation2ágithubácomágitábugágitábugáentitiesábugáAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
2101 if v == nil {
2102 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2103 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2104 }
2105 return graphql.Null
2106 }
2107 return ec._BugAddCommentOperation(ctx, sel, v)
2108}
2109
2110func (ec *executionContext) marshalNBugCreateOperation2ágithubácomágitábugágitábugáentitiesábugáCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
2111 if v == nil {
2112 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2113 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2114 }
2115 return graphql.Null
2116 }
2117 return ec._BugCreateOperation(ctx, sel, v)
2118}
2119
2120func (ec *executionContext) marshalNBugEditCommentOperation2ágithubácomágitábugágitábugáentitiesábugáEditCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.EditCommentOperation) graphql.Marshaler {
2121 if v == nil {
2122 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2123 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2124 }
2125 return graphql.Null
2126 }
2127 return ec._BugEditCommentOperation(ctx, sel, v)
2128}
2129
2130func (ec *executionContext) marshalNBugLabelChangeOperation2ágithubácomágitábugágitábugáentitiesábugáLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
2131 if v == nil {
2132 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2133 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2134 }
2135 return graphql.Null
2136 }
2137 return ec._BugLabelChangeOperation(ctx, sel, v)
2138}
2139
2140func (ec *executionContext) marshalNBugSetStatusOperation2ágithubácomágitábugágitábugáentitiesábugáSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
2141 if v == nil {
2142 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2143 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2144 }
2145 return graphql.Null
2146 }
2147 return ec._BugSetStatusOperation(ctx, sel, v)
2148}
2149
2150func (ec *executionContext) marshalNBugSetTitleOperation2ágithubácomágitábugágitábugáentitiesábugáSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
2151 if v == nil {
2152 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2153 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2154 }
2155 return graphql.Null
2156 }
2157 return ec._BugSetTitleOperation(ctx, sel, v)
2158}
2159
2160// endregion ***************************** type.gotpl *****************************