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
12 "github.com/99designs/gqlgen/graphql"
13 "github.com/git-bug/git-bug/api/graphql/models"
14 "github.com/vektah/gqlparser/v2/ast"
15)
16
17// region ************************** generated!.gotpl **************************
18
19type RepositoryResolver interface {
20 Name(ctx context.Context, obj *models.Repository) (*string, error)
21 AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
22 Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
23 AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
24 Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
25 UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
26 ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
27}
28
29// endregion ************************** generated!.gotpl **************************
30
31// region ***************************** args.gotpl *****************************
32
33func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
34 var err error
35 args := map[string]any{}
36 arg0, err := ec.field_Repository_allBugs_argsAfter(ctx, rawArgs)
37 if err != nil {
38 return nil, err
39 }
40 args["after"] = arg0
41 arg1, err := ec.field_Repository_allBugs_argsBefore(ctx, rawArgs)
42 if err != nil {
43 return nil, err
44 }
45 args["before"] = arg1
46 arg2, err := ec.field_Repository_allBugs_argsFirst(ctx, rawArgs)
47 if err != nil {
48 return nil, err
49 }
50 args["first"] = arg2
51 arg3, err := ec.field_Repository_allBugs_argsLast(ctx, rawArgs)
52 if err != nil {
53 return nil, err
54 }
55 args["last"] = arg3
56 arg4, err := ec.field_Repository_allBugs_argsQuery(ctx, rawArgs)
57 if err != nil {
58 return nil, err
59 }
60 args["query"] = arg4
61 return args, nil
62}
63func (ec *executionContext) field_Repository_allBugs_argsAfter(
64 ctx context.Context,
65 rawArgs map[string]any,
66) (*string, error) {
67 if _, ok := rawArgs["after"]; !ok {
68 var zeroVal *string
69 return zeroVal, nil
70 }
71
72 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
73 if tmp, ok := rawArgs["after"]; ok {
74 return ec.unmarshalOString2ᚖstring(ctx, tmp)
75 }
76
77 var zeroVal *string
78 return zeroVal, nil
79}
80
81func (ec *executionContext) field_Repository_allBugs_argsBefore(
82 ctx context.Context,
83 rawArgs map[string]any,
84) (*string, error) {
85 if _, ok := rawArgs["before"]; !ok {
86 var zeroVal *string
87 return zeroVal, nil
88 }
89
90 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
91 if tmp, ok := rawArgs["before"]; ok {
92 return ec.unmarshalOString2ᚖstring(ctx, tmp)
93 }
94
95 var zeroVal *string
96 return zeroVal, nil
97}
98
99func (ec *executionContext) field_Repository_allBugs_argsFirst(
100 ctx context.Context,
101 rawArgs map[string]any,
102) (*int, error) {
103 if _, ok := rawArgs["first"]; !ok {
104 var zeroVal *int
105 return zeroVal, nil
106 }
107
108 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
109 if tmp, ok := rawArgs["first"]; ok {
110 return ec.unmarshalOInt2ᚖint(ctx, tmp)
111 }
112
113 var zeroVal *int
114 return zeroVal, nil
115}
116
117func (ec *executionContext) field_Repository_allBugs_argsLast(
118 ctx context.Context,
119 rawArgs map[string]any,
120) (*int, error) {
121 if _, ok := rawArgs["last"]; !ok {
122 var zeroVal *int
123 return zeroVal, nil
124 }
125
126 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
127 if tmp, ok := rawArgs["last"]; ok {
128 return ec.unmarshalOInt2ᚖint(ctx, tmp)
129 }
130
131 var zeroVal *int
132 return zeroVal, nil
133}
134
135func (ec *executionContext) field_Repository_allBugs_argsQuery(
136 ctx context.Context,
137 rawArgs map[string]any,
138) (*string, error) {
139 if _, ok := rawArgs["query"]; !ok {
140 var zeroVal *string
141 return zeroVal, nil
142 }
143
144 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query"))
145 if tmp, ok := rawArgs["query"]; ok {
146 return ec.unmarshalOString2ᚖstring(ctx, tmp)
147 }
148
149 var zeroVal *string
150 return zeroVal, nil
151}
152
153func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
154 var err error
155 args := map[string]any{}
156 arg0, err := ec.field_Repository_allIdentities_argsAfter(ctx, rawArgs)
157 if err != nil {
158 return nil, err
159 }
160 args["after"] = arg0
161 arg1, err := ec.field_Repository_allIdentities_argsBefore(ctx, rawArgs)
162 if err != nil {
163 return nil, err
164 }
165 args["before"] = arg1
166 arg2, err := ec.field_Repository_allIdentities_argsFirst(ctx, rawArgs)
167 if err != nil {
168 return nil, err
169 }
170 args["first"] = arg2
171 arg3, err := ec.field_Repository_allIdentities_argsLast(ctx, rawArgs)
172 if err != nil {
173 return nil, err
174 }
175 args["last"] = arg3
176 return args, nil
177}
178func (ec *executionContext) field_Repository_allIdentities_argsAfter(
179 ctx context.Context,
180 rawArgs map[string]any,
181) (*string, error) {
182 if _, ok := rawArgs["after"]; !ok {
183 var zeroVal *string
184 return zeroVal, nil
185 }
186
187 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
188 if tmp, ok := rawArgs["after"]; ok {
189 return ec.unmarshalOString2ᚖstring(ctx, tmp)
190 }
191
192 var zeroVal *string
193 return zeroVal, nil
194}
195
196func (ec *executionContext) field_Repository_allIdentities_argsBefore(
197 ctx context.Context,
198 rawArgs map[string]any,
199) (*string, error) {
200 if _, ok := rawArgs["before"]; !ok {
201 var zeroVal *string
202 return zeroVal, nil
203 }
204
205 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
206 if tmp, ok := rawArgs["before"]; ok {
207 return ec.unmarshalOString2ᚖstring(ctx, tmp)
208 }
209
210 var zeroVal *string
211 return zeroVal, nil
212}
213
214func (ec *executionContext) field_Repository_allIdentities_argsFirst(
215 ctx context.Context,
216 rawArgs map[string]any,
217) (*int, error) {
218 if _, ok := rawArgs["first"]; !ok {
219 var zeroVal *int
220 return zeroVal, nil
221 }
222
223 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
224 if tmp, ok := rawArgs["first"]; ok {
225 return ec.unmarshalOInt2ᚖint(ctx, tmp)
226 }
227
228 var zeroVal *int
229 return zeroVal, nil
230}
231
232func (ec *executionContext) field_Repository_allIdentities_argsLast(
233 ctx context.Context,
234 rawArgs map[string]any,
235) (*int, error) {
236 if _, ok := rawArgs["last"]; !ok {
237 var zeroVal *int
238 return zeroVal, nil
239 }
240
241 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
242 if tmp, ok := rawArgs["last"]; ok {
243 return ec.unmarshalOInt2ᚖint(ctx, tmp)
244 }
245
246 var zeroVal *int
247 return zeroVal, nil
248}
249
250func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
251 var err error
252 args := map[string]any{}
253 arg0, err := ec.field_Repository_bug_argsPrefix(ctx, rawArgs)
254 if err != nil {
255 return nil, err
256 }
257 args["prefix"] = arg0
258 return args, nil
259}
260func (ec *executionContext) field_Repository_bug_argsPrefix(
261 ctx context.Context,
262 rawArgs map[string]any,
263) (string, error) {
264 if _, ok := rawArgs["prefix"]; !ok {
265 var zeroVal string
266 return zeroVal, nil
267 }
268
269 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
270 if tmp, ok := rawArgs["prefix"]; ok {
271 return ec.unmarshalNString2string(ctx, tmp)
272 }
273
274 var zeroVal string
275 return zeroVal, nil
276}
277
278func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
279 var err error
280 args := map[string]any{}
281 arg0, err := ec.field_Repository_identity_argsPrefix(ctx, rawArgs)
282 if err != nil {
283 return nil, err
284 }
285 args["prefix"] = arg0
286 return args, nil
287}
288func (ec *executionContext) field_Repository_identity_argsPrefix(
289 ctx context.Context,
290 rawArgs map[string]any,
291) (string, error) {
292 if _, ok := rawArgs["prefix"]; !ok {
293 var zeroVal string
294 return zeroVal, nil
295 }
296
297 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
298 if tmp, ok := rawArgs["prefix"]; ok {
299 return ec.unmarshalNString2string(ctx, tmp)
300 }
301
302 var zeroVal string
303 return zeroVal, nil
304}
305
306func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
307 var err error
308 args := map[string]any{}
309 arg0, err := ec.field_Repository_validLabels_argsAfter(ctx, rawArgs)
310 if err != nil {
311 return nil, err
312 }
313 args["after"] = arg0
314 arg1, err := ec.field_Repository_validLabels_argsBefore(ctx, rawArgs)
315 if err != nil {
316 return nil, err
317 }
318 args["before"] = arg1
319 arg2, err := ec.field_Repository_validLabels_argsFirst(ctx, rawArgs)
320 if err != nil {
321 return nil, err
322 }
323 args["first"] = arg2
324 arg3, err := ec.field_Repository_validLabels_argsLast(ctx, rawArgs)
325 if err != nil {
326 return nil, err
327 }
328 args["last"] = arg3
329 return args, nil
330}
331func (ec *executionContext) field_Repository_validLabels_argsAfter(
332 ctx context.Context,
333 rawArgs map[string]any,
334) (*string, error) {
335 if _, ok := rawArgs["after"]; !ok {
336 var zeroVal *string
337 return zeroVal, nil
338 }
339
340 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
341 if tmp, ok := rawArgs["after"]; ok {
342 return ec.unmarshalOString2ᚖstring(ctx, tmp)
343 }
344
345 var zeroVal *string
346 return zeroVal, nil
347}
348
349func (ec *executionContext) field_Repository_validLabels_argsBefore(
350 ctx context.Context,
351 rawArgs map[string]any,
352) (*string, error) {
353 if _, ok := rawArgs["before"]; !ok {
354 var zeroVal *string
355 return zeroVal, nil
356 }
357
358 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
359 if tmp, ok := rawArgs["before"]; ok {
360 return ec.unmarshalOString2ᚖstring(ctx, tmp)
361 }
362
363 var zeroVal *string
364 return zeroVal, nil
365}
366
367func (ec *executionContext) field_Repository_validLabels_argsFirst(
368 ctx context.Context,
369 rawArgs map[string]any,
370) (*int, error) {
371 if _, ok := rawArgs["first"]; !ok {
372 var zeroVal *int
373 return zeroVal, nil
374 }
375
376 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
377 if tmp, ok := rawArgs["first"]; ok {
378 return ec.unmarshalOInt2ᚖint(ctx, tmp)
379 }
380
381 var zeroVal *int
382 return zeroVal, nil
383}
384
385func (ec *executionContext) field_Repository_validLabels_argsLast(
386 ctx context.Context,
387 rawArgs map[string]any,
388) (*int, error) {
389 if _, ok := rawArgs["last"]; !ok {
390 var zeroVal *int
391 return zeroVal, nil
392 }
393
394 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
395 if tmp, ok := rawArgs["last"]; ok {
396 return ec.unmarshalOInt2ᚖint(ctx, tmp)
397 }
398
399 var zeroVal *int
400 return zeroVal, nil
401}
402
403// endregion ***************************** args.gotpl *****************************
404
405// region ************************** directives.gotpl **************************
406
407// endregion ************************** directives.gotpl **************************
408
409// region **************************** field.gotpl *****************************
410
411func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
412 fc, err := ec.fieldContext_Repository_name(ctx, field)
413 if err != nil {
414 return graphql.Null
415 }
416 ctx = graphql.WithFieldContext(ctx, fc)
417 defer func() {
418 if r := recover(); r != nil {
419 ec.Error(ctx, ec.Recover(ctx, r))
420 ret = graphql.Null
421 }
422 }()
423 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
424 ctx = rctx // use context from middleware stack in children
425 return ec.resolvers.Repository().Name(rctx, obj)
426 })
427 if err != nil {
428 ec.Error(ctx, err)
429 return graphql.Null
430 }
431 if resTmp == nil {
432 return graphql.Null
433 }
434 res := resTmp.(*string)
435 fc.Result = res
436 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
437}
438
439func (ec *executionContext) fieldContext_Repository_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
440 fc = &graphql.FieldContext{
441 Object: "Repository",
442 Field: field,
443 IsMethod: true,
444 IsResolver: true,
445 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
446 return nil, errors.New("field of type String does not have child fields")
447 },
448 }
449 return fc, nil
450}
451
452func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
453 fc, err := ec.fieldContext_Repository_allBugs(ctx, field)
454 if err != nil {
455 return graphql.Null
456 }
457 ctx = graphql.WithFieldContext(ctx, fc)
458 defer func() {
459 if r := recover(); r != nil {
460 ec.Error(ctx, ec.Recover(ctx, r))
461 ret = graphql.Null
462 }
463 }()
464 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
465 ctx = rctx // use context from middleware stack in children
466 return ec.resolvers.Repository().AllBugs(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int), fc.Args["query"].(*string))
467 })
468 if err != nil {
469 ec.Error(ctx, err)
470 return graphql.Null
471 }
472 if resTmp == nil {
473 if !graphql.HasFieldError(ctx, fc) {
474 ec.Errorf(ctx, "must not be null")
475 }
476 return graphql.Null
477 }
478 res := resTmp.(*models.BugConnection)
479 fc.Result = res
480 return ec.marshalNBugConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
481}
482
483func (ec *executionContext) fieldContext_Repository_allBugs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
484 fc = &graphql.FieldContext{
485 Object: "Repository",
486 Field: field,
487 IsMethod: true,
488 IsResolver: true,
489 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
490 switch field.Name {
491 case "edges":
492 return ec.fieldContext_BugConnection_edges(ctx, field)
493 case "nodes":
494 return ec.fieldContext_BugConnection_nodes(ctx, field)
495 case "pageInfo":
496 return ec.fieldContext_BugConnection_pageInfo(ctx, field)
497 case "totalCount":
498 return ec.fieldContext_BugConnection_totalCount(ctx, field)
499 }
500 return nil, fmt.Errorf("no field named %q was found under type BugConnection", field.Name)
501 },
502 }
503 defer func() {
504 if r := recover(); r != nil {
505 err = ec.Recover(ctx, r)
506 ec.Error(ctx, err)
507 }
508 }()
509 ctx = graphql.WithFieldContext(ctx, fc)
510 if fc.Args, err = ec.field_Repository_allBugs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
511 ec.Error(ctx, err)
512 return fc, err
513 }
514 return fc, nil
515}
516
517func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
518 fc, err := ec.fieldContext_Repository_bug(ctx, field)
519 if err != nil {
520 return graphql.Null
521 }
522 ctx = graphql.WithFieldContext(ctx, fc)
523 defer func() {
524 if r := recover(); r != nil {
525 ec.Error(ctx, ec.Recover(ctx, r))
526 ret = graphql.Null
527 }
528 }()
529 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
530 ctx = rctx // use context from middleware stack in children
531 return ec.resolvers.Repository().Bug(rctx, obj, fc.Args["prefix"].(string))
532 })
533 if err != nil {
534 ec.Error(ctx, err)
535 return graphql.Null
536 }
537 if resTmp == nil {
538 return graphql.Null
539 }
540 res := resTmp.(models.BugWrapper)
541 fc.Result = res
542 return ec.marshalOBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
543}
544
545func (ec *executionContext) fieldContext_Repository_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
546 fc = &graphql.FieldContext{
547 Object: "Repository",
548 Field: field,
549 IsMethod: true,
550 IsResolver: true,
551 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
552 switch field.Name {
553 case "id":
554 return ec.fieldContext_Bug_id(ctx, field)
555 case "humanId":
556 return ec.fieldContext_Bug_humanId(ctx, field)
557 case "createdAt":
558 return ec.fieldContext_Bug_createdAt(ctx, field)
559 case "lastEdit":
560 return ec.fieldContext_Bug_lastEdit(ctx, field)
561 case "status":
562 return ec.fieldContext_Bug_status(ctx, field)
563 case "title":
564 return ec.fieldContext_Bug_title(ctx, field)
565 case "labels":
566 return ec.fieldContext_Bug_labels(ctx, field)
567 case "author":
568 return ec.fieldContext_Bug_author(ctx, field)
569 case "actors":
570 return ec.fieldContext_Bug_actors(ctx, field)
571 case "participants":
572 return ec.fieldContext_Bug_participants(ctx, field)
573 case "comments":
574 return ec.fieldContext_Bug_comments(ctx, field)
575 case "timeline":
576 return ec.fieldContext_Bug_timeline(ctx, field)
577 case "operations":
578 return ec.fieldContext_Bug_operations(ctx, field)
579 }
580 return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
581 },
582 }
583 defer func() {
584 if r := recover(); r != nil {
585 err = ec.Recover(ctx, r)
586 ec.Error(ctx, err)
587 }
588 }()
589 ctx = graphql.WithFieldContext(ctx, fc)
590 if fc.Args, err = ec.field_Repository_bug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
591 ec.Error(ctx, err)
592 return fc, err
593 }
594 return fc, nil
595}
596
597func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
598 fc, err := ec.fieldContext_Repository_allIdentities(ctx, field)
599 if err != nil {
600 return graphql.Null
601 }
602 ctx = graphql.WithFieldContext(ctx, fc)
603 defer func() {
604 if r := recover(); r != nil {
605 ec.Error(ctx, ec.Recover(ctx, r))
606 ret = graphql.Null
607 }
608 }()
609 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
610 ctx = rctx // use context from middleware stack in children
611 return ec.resolvers.Repository().AllIdentities(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
612 })
613 if err != nil {
614 ec.Error(ctx, err)
615 return graphql.Null
616 }
617 if resTmp == nil {
618 if !graphql.HasFieldError(ctx, fc) {
619 ec.Errorf(ctx, "must not be null")
620 }
621 return graphql.Null
622 }
623 res := resTmp.(*models.IdentityConnection)
624 fc.Result = res
625 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
626}
627
628func (ec *executionContext) fieldContext_Repository_allIdentities(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
629 fc = &graphql.FieldContext{
630 Object: "Repository",
631 Field: field,
632 IsMethod: true,
633 IsResolver: true,
634 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
635 switch field.Name {
636 case "edges":
637 return ec.fieldContext_IdentityConnection_edges(ctx, field)
638 case "nodes":
639 return ec.fieldContext_IdentityConnection_nodes(ctx, field)
640 case "pageInfo":
641 return ec.fieldContext_IdentityConnection_pageInfo(ctx, field)
642 case "totalCount":
643 return ec.fieldContext_IdentityConnection_totalCount(ctx, field)
644 }
645 return nil, fmt.Errorf("no field named %q was found under type IdentityConnection", field.Name)
646 },
647 }
648 defer func() {
649 if r := recover(); r != nil {
650 err = ec.Recover(ctx, r)
651 ec.Error(ctx, err)
652 }
653 }()
654 ctx = graphql.WithFieldContext(ctx, fc)
655 if fc.Args, err = ec.field_Repository_allIdentities_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
656 ec.Error(ctx, err)
657 return fc, err
658 }
659 return fc, nil
660}
661
662func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
663 fc, err := ec.fieldContext_Repository_identity(ctx, field)
664 if err != nil {
665 return graphql.Null
666 }
667 ctx = graphql.WithFieldContext(ctx, fc)
668 defer func() {
669 if r := recover(); r != nil {
670 ec.Error(ctx, ec.Recover(ctx, r))
671 ret = graphql.Null
672 }
673 }()
674 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
675 ctx = rctx // use context from middleware stack in children
676 return ec.resolvers.Repository().Identity(rctx, obj, fc.Args["prefix"].(string))
677 })
678 if err != nil {
679 ec.Error(ctx, err)
680 return graphql.Null
681 }
682 if resTmp == nil {
683 return graphql.Null
684 }
685 res := resTmp.(models.IdentityWrapper)
686 fc.Result = res
687 return ec.marshalOIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
688}
689
690func (ec *executionContext) fieldContext_Repository_identity(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
691 fc = &graphql.FieldContext{
692 Object: "Repository",
693 Field: field,
694 IsMethod: true,
695 IsResolver: true,
696 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
697 switch field.Name {
698 case "id":
699 return ec.fieldContext_Identity_id(ctx, field)
700 case "humanId":
701 return ec.fieldContext_Identity_humanId(ctx, field)
702 case "name":
703 return ec.fieldContext_Identity_name(ctx, field)
704 case "email":
705 return ec.fieldContext_Identity_email(ctx, field)
706 case "login":
707 return ec.fieldContext_Identity_login(ctx, field)
708 case "displayName":
709 return ec.fieldContext_Identity_displayName(ctx, field)
710 case "avatarUrl":
711 return ec.fieldContext_Identity_avatarUrl(ctx, field)
712 case "isProtected":
713 return ec.fieldContext_Identity_isProtected(ctx, field)
714 }
715 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
716 },
717 }
718 defer func() {
719 if r := recover(); r != nil {
720 err = ec.Recover(ctx, r)
721 ec.Error(ctx, err)
722 }
723 }()
724 ctx = graphql.WithFieldContext(ctx, fc)
725 if fc.Args, err = ec.field_Repository_identity_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
726 ec.Error(ctx, err)
727 return fc, err
728 }
729 return fc, nil
730}
731
732func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
733 fc, err := ec.fieldContext_Repository_userIdentity(ctx, field)
734 if err != nil {
735 return graphql.Null
736 }
737 ctx = graphql.WithFieldContext(ctx, fc)
738 defer func() {
739 if r := recover(); r != nil {
740 ec.Error(ctx, ec.Recover(ctx, r))
741 ret = graphql.Null
742 }
743 }()
744 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
745 ctx = rctx // use context from middleware stack in children
746 return ec.resolvers.Repository().UserIdentity(rctx, obj)
747 })
748 if err != nil {
749 ec.Error(ctx, err)
750 return graphql.Null
751 }
752 if resTmp == nil {
753 return graphql.Null
754 }
755 res := resTmp.(models.IdentityWrapper)
756 fc.Result = res
757 return ec.marshalOIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
758}
759
760func (ec *executionContext) fieldContext_Repository_userIdentity(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
761 fc = &graphql.FieldContext{
762 Object: "Repository",
763 Field: field,
764 IsMethod: true,
765 IsResolver: true,
766 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
767 switch field.Name {
768 case "id":
769 return ec.fieldContext_Identity_id(ctx, field)
770 case "humanId":
771 return ec.fieldContext_Identity_humanId(ctx, field)
772 case "name":
773 return ec.fieldContext_Identity_name(ctx, field)
774 case "email":
775 return ec.fieldContext_Identity_email(ctx, field)
776 case "login":
777 return ec.fieldContext_Identity_login(ctx, field)
778 case "displayName":
779 return ec.fieldContext_Identity_displayName(ctx, field)
780 case "avatarUrl":
781 return ec.fieldContext_Identity_avatarUrl(ctx, field)
782 case "isProtected":
783 return ec.fieldContext_Identity_isProtected(ctx, field)
784 }
785 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
786 },
787 }
788 return fc, nil
789}
790
791func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
792 fc, err := ec.fieldContext_Repository_validLabels(ctx, field)
793 if err != nil {
794 return graphql.Null
795 }
796 ctx = graphql.WithFieldContext(ctx, fc)
797 defer func() {
798 if r := recover(); r != nil {
799 ec.Error(ctx, ec.Recover(ctx, r))
800 ret = graphql.Null
801 }
802 }()
803 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
804 ctx = rctx // use context from middleware stack in children
805 return ec.resolvers.Repository().ValidLabels(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
806 })
807 if err != nil {
808 ec.Error(ctx, err)
809 return graphql.Null
810 }
811 if resTmp == nil {
812 if !graphql.HasFieldError(ctx, fc) {
813 ec.Errorf(ctx, "must not be null")
814 }
815 return graphql.Null
816 }
817 res := resTmp.(*models.LabelConnection)
818 fc.Result = res
819 return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
820}
821
822func (ec *executionContext) fieldContext_Repository_validLabels(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
823 fc = &graphql.FieldContext{
824 Object: "Repository",
825 Field: field,
826 IsMethod: true,
827 IsResolver: true,
828 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
829 switch field.Name {
830 case "edges":
831 return ec.fieldContext_LabelConnection_edges(ctx, field)
832 case "nodes":
833 return ec.fieldContext_LabelConnection_nodes(ctx, field)
834 case "pageInfo":
835 return ec.fieldContext_LabelConnection_pageInfo(ctx, field)
836 case "totalCount":
837 return ec.fieldContext_LabelConnection_totalCount(ctx, field)
838 }
839 return nil, fmt.Errorf("no field named %q was found under type LabelConnection", field.Name)
840 },
841 }
842 defer func() {
843 if r := recover(); r != nil {
844 err = ec.Recover(ctx, r)
845 ec.Error(ctx, err)
846 }
847 }()
848 ctx = graphql.WithFieldContext(ctx, fc)
849 if fc.Args, err = ec.field_Repository_validLabels_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
850 ec.Error(ctx, err)
851 return fc, err
852 }
853 return fc, nil
854}
855
856// endregion **************************** field.gotpl *****************************
857
858// region **************************** input.gotpl *****************************
859
860// endregion **************************** input.gotpl *****************************
861
862// region ************************** interface.gotpl ***************************
863
864// endregion ************************** interface.gotpl ***************************
865
866// region **************************** object.gotpl ****************************
867
868var repositoryImplementors = []string{"Repository"}
869
870func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
871 fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
872
873 out := graphql.NewFieldSet(fields)
874 deferred := make(map[string]*graphql.FieldSet)
875 for i, field := range fields {
876 switch field.Name {
877 case "__typename":
878 out.Values[i] = graphql.MarshalString("Repository")
879 case "name":
880 field := field
881
882 innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
883 defer func() {
884 if r := recover(); r != nil {
885 ec.Error(ctx, ec.Recover(ctx, r))
886 }
887 }()
888 res = ec._Repository_name(ctx, field, obj)
889 return res
890 }
891
892 if field.Deferrable != nil {
893 dfs, ok := deferred[field.Deferrable.Label]
894 di := 0
895 if ok {
896 dfs.AddField(field)
897 di = len(dfs.Values) - 1
898 } else {
899 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
900 deferred[field.Deferrable.Label] = dfs
901 }
902 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
903 return innerFunc(ctx, dfs)
904 })
905
906 // don't run the out.Concurrently() call below
907 out.Values[i] = graphql.Null
908 continue
909 }
910
911 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
912 case "allBugs":
913 field := field
914
915 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
916 defer func() {
917 if r := recover(); r != nil {
918 ec.Error(ctx, ec.Recover(ctx, r))
919 }
920 }()
921 res = ec._Repository_allBugs(ctx, field, obj)
922 if res == graphql.Null {
923 atomic.AddUint32(&fs.Invalids, 1)
924 }
925 return res
926 }
927
928 if field.Deferrable != nil {
929 dfs, ok := deferred[field.Deferrable.Label]
930 di := 0
931 if ok {
932 dfs.AddField(field)
933 di = len(dfs.Values) - 1
934 } else {
935 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
936 deferred[field.Deferrable.Label] = dfs
937 }
938 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
939 return innerFunc(ctx, dfs)
940 })
941
942 // don't run the out.Concurrently() call below
943 out.Values[i] = graphql.Null
944 continue
945 }
946
947 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
948 case "bug":
949 field := field
950
951 innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
952 defer func() {
953 if r := recover(); r != nil {
954 ec.Error(ctx, ec.Recover(ctx, r))
955 }
956 }()
957 res = ec._Repository_bug(ctx, field, obj)
958 return res
959 }
960
961 if field.Deferrable != nil {
962 dfs, ok := deferred[field.Deferrable.Label]
963 di := 0
964 if ok {
965 dfs.AddField(field)
966 di = len(dfs.Values) - 1
967 } else {
968 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
969 deferred[field.Deferrable.Label] = dfs
970 }
971 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
972 return innerFunc(ctx, dfs)
973 })
974
975 // don't run the out.Concurrently() call below
976 out.Values[i] = graphql.Null
977 continue
978 }
979
980 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
981 case "allIdentities":
982 field := field
983
984 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
985 defer func() {
986 if r := recover(); r != nil {
987 ec.Error(ctx, ec.Recover(ctx, r))
988 }
989 }()
990 res = ec._Repository_allIdentities(ctx, field, obj)
991 if res == graphql.Null {
992 atomic.AddUint32(&fs.Invalids, 1)
993 }
994 return res
995 }
996
997 if field.Deferrable != nil {
998 dfs, ok := deferred[field.Deferrable.Label]
999 di := 0
1000 if ok {
1001 dfs.AddField(field)
1002 di = len(dfs.Values) - 1
1003 } else {
1004 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1005 deferred[field.Deferrable.Label] = dfs
1006 }
1007 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1008 return innerFunc(ctx, dfs)
1009 })
1010
1011 // don't run the out.Concurrently() call below
1012 out.Values[i] = graphql.Null
1013 continue
1014 }
1015
1016 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1017 case "identity":
1018 field := field
1019
1020 innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
1021 defer func() {
1022 if r := recover(); r != nil {
1023 ec.Error(ctx, ec.Recover(ctx, r))
1024 }
1025 }()
1026 res = ec._Repository_identity(ctx, field, obj)
1027 return res
1028 }
1029
1030 if field.Deferrable != nil {
1031 dfs, ok := deferred[field.Deferrable.Label]
1032 di := 0
1033 if ok {
1034 dfs.AddField(field)
1035 di = len(dfs.Values) - 1
1036 } else {
1037 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1038 deferred[field.Deferrable.Label] = dfs
1039 }
1040 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1041 return innerFunc(ctx, dfs)
1042 })
1043
1044 // don't run the out.Concurrently() call below
1045 out.Values[i] = graphql.Null
1046 continue
1047 }
1048
1049 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1050 case "userIdentity":
1051 field := field
1052
1053 innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
1054 defer func() {
1055 if r := recover(); r != nil {
1056 ec.Error(ctx, ec.Recover(ctx, r))
1057 }
1058 }()
1059 res = ec._Repository_userIdentity(ctx, field, obj)
1060 return res
1061 }
1062
1063 if field.Deferrable != nil {
1064 dfs, ok := deferred[field.Deferrable.Label]
1065 di := 0
1066 if ok {
1067 dfs.AddField(field)
1068 di = len(dfs.Values) - 1
1069 } else {
1070 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1071 deferred[field.Deferrable.Label] = dfs
1072 }
1073 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1074 return innerFunc(ctx, dfs)
1075 })
1076
1077 // don't run the out.Concurrently() call below
1078 out.Values[i] = graphql.Null
1079 continue
1080 }
1081
1082 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1083 case "validLabels":
1084 field := field
1085
1086 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1087 defer func() {
1088 if r := recover(); r != nil {
1089 ec.Error(ctx, ec.Recover(ctx, r))
1090 }
1091 }()
1092 res = ec._Repository_validLabels(ctx, field, obj)
1093 if res == graphql.Null {
1094 atomic.AddUint32(&fs.Invalids, 1)
1095 }
1096 return res
1097 }
1098
1099 if field.Deferrable != nil {
1100 dfs, ok := deferred[field.Deferrable.Label]
1101 di := 0
1102 if ok {
1103 dfs.AddField(field)
1104 di = len(dfs.Values) - 1
1105 } else {
1106 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1107 deferred[field.Deferrable.Label] = dfs
1108 }
1109 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1110 return innerFunc(ctx, dfs)
1111 })
1112
1113 // don't run the out.Concurrently() call below
1114 out.Values[i] = graphql.Null
1115 continue
1116 }
1117
1118 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1119 default:
1120 panic("unknown field " + strconv.Quote(field.Name))
1121 }
1122 }
1123 out.Dispatch(ctx)
1124 if out.Invalids > 0 {
1125 return graphql.Null
1126 }
1127
1128 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1129
1130 for label, dfs := range deferred {
1131 ec.processDeferredGroup(graphql.DeferredGroup{
1132 Label: label,
1133 Path: graphql.GetPath(ctx),
1134 FieldSet: dfs,
1135 Context: ctx,
1136 })
1137 }
1138
1139 return out
1140}
1141
1142// endregion **************************** object.gotpl ****************************
1143
1144// region ***************************** type.gotpl *****************************
1145
1146func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
1147 if v == nil {
1148 return graphql.Null
1149 }
1150 return ec._Repository(ctx, sel, v)
1151}
1152
1153// endregion ***************************** type.gotpl *****************************