1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
2
3package graph
4
5import (
6 "context"
7 "errors"
8 "fmt"
9 "strconv"
10 "sync"
11 "sync/atomic"
12 "time"
13
14 "github.com/99designs/gqlgen/graphql"
15 "github.com/git-bug/git-bug/api/graphql/models"
16 "github.com/git-bug/git-bug/entity"
17 "github.com/vektah/gqlparser/v2/ast"
18)
19
20// region ************************** generated!.gotpl **************************
21
22type BoardResolver interface {
23 HumanID(ctx context.Context, obj models.BoardWrapper) (string, error)
24
25 Columns(ctx context.Context, obj models.BoardWrapper, after *string, before *string, first *int, last *int) (*models.BoardColumnConnection, error)
26 Actors(ctx context.Context, obj models.BoardWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
27 Operations(ctx context.Context, obj models.BoardWrapper, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
28}
29
30// endregion ************************** generated!.gotpl **************************
31
32// region ***************************** args.gotpl *****************************
33
34func (ec *executionContext) field_Board_actors_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
35 var err error
36 args := map[string]any{}
37 arg0, err := ec.field_Board_actors_argsAfter(ctx, rawArgs)
38 if err != nil {
39 return nil, err
40 }
41 args["after"] = arg0
42 arg1, err := ec.field_Board_actors_argsBefore(ctx, rawArgs)
43 if err != nil {
44 return nil, err
45 }
46 args["before"] = arg1
47 arg2, err := ec.field_Board_actors_argsFirst(ctx, rawArgs)
48 if err != nil {
49 return nil, err
50 }
51 args["first"] = arg2
52 arg3, err := ec.field_Board_actors_argsLast(ctx, rawArgs)
53 if err != nil {
54 return nil, err
55 }
56 args["last"] = arg3
57 return args, nil
58}
59func (ec *executionContext) field_Board_actors_argsAfter(
60 ctx context.Context,
61 rawArgs map[string]any,
62) (*string, error) {
63 if _, ok := rawArgs["after"]; !ok {
64 var zeroVal *string
65 return zeroVal, nil
66 }
67
68 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
69 if tmp, ok := rawArgs["after"]; ok {
70 return ec.unmarshalOString2ᚖstring(ctx, tmp)
71 }
72
73 var zeroVal *string
74 return zeroVal, nil
75}
76
77func (ec *executionContext) field_Board_actors_argsBefore(
78 ctx context.Context,
79 rawArgs map[string]any,
80) (*string, error) {
81 if _, ok := rawArgs["before"]; !ok {
82 var zeroVal *string
83 return zeroVal, nil
84 }
85
86 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
87 if tmp, ok := rawArgs["before"]; ok {
88 return ec.unmarshalOString2ᚖstring(ctx, tmp)
89 }
90
91 var zeroVal *string
92 return zeroVal, nil
93}
94
95func (ec *executionContext) field_Board_actors_argsFirst(
96 ctx context.Context,
97 rawArgs map[string]any,
98) (*int, error) {
99 if _, ok := rawArgs["first"]; !ok {
100 var zeroVal *int
101 return zeroVal, nil
102 }
103
104 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
105 if tmp, ok := rawArgs["first"]; ok {
106 return ec.unmarshalOInt2ᚖint(ctx, tmp)
107 }
108
109 var zeroVal *int
110 return zeroVal, nil
111}
112
113func (ec *executionContext) field_Board_actors_argsLast(
114 ctx context.Context,
115 rawArgs map[string]any,
116) (*int, error) {
117 if _, ok := rawArgs["last"]; !ok {
118 var zeroVal *int
119 return zeroVal, nil
120 }
121
122 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
123 if tmp, ok := rawArgs["last"]; ok {
124 return ec.unmarshalOInt2ᚖint(ctx, tmp)
125 }
126
127 var zeroVal *int
128 return zeroVal, nil
129}
130
131func (ec *executionContext) field_Board_columns_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
132 var err error
133 args := map[string]any{}
134 arg0, err := ec.field_Board_columns_argsAfter(ctx, rawArgs)
135 if err != nil {
136 return nil, err
137 }
138 args["after"] = arg0
139 arg1, err := ec.field_Board_columns_argsBefore(ctx, rawArgs)
140 if err != nil {
141 return nil, err
142 }
143 args["before"] = arg1
144 arg2, err := ec.field_Board_columns_argsFirst(ctx, rawArgs)
145 if err != nil {
146 return nil, err
147 }
148 args["first"] = arg2
149 arg3, err := ec.field_Board_columns_argsLast(ctx, rawArgs)
150 if err != nil {
151 return nil, err
152 }
153 args["last"] = arg3
154 return args, nil
155}
156func (ec *executionContext) field_Board_columns_argsAfter(
157 ctx context.Context,
158 rawArgs map[string]any,
159) (*string, error) {
160 if _, ok := rawArgs["after"]; !ok {
161 var zeroVal *string
162 return zeroVal, nil
163 }
164
165 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
166 if tmp, ok := rawArgs["after"]; ok {
167 return ec.unmarshalOString2ᚖstring(ctx, tmp)
168 }
169
170 var zeroVal *string
171 return zeroVal, nil
172}
173
174func (ec *executionContext) field_Board_columns_argsBefore(
175 ctx context.Context,
176 rawArgs map[string]any,
177) (*string, error) {
178 if _, ok := rawArgs["before"]; !ok {
179 var zeroVal *string
180 return zeroVal, nil
181 }
182
183 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
184 if tmp, ok := rawArgs["before"]; ok {
185 return ec.unmarshalOString2ᚖstring(ctx, tmp)
186 }
187
188 var zeroVal *string
189 return zeroVal, nil
190}
191
192func (ec *executionContext) field_Board_columns_argsFirst(
193 ctx context.Context,
194 rawArgs map[string]any,
195) (*int, error) {
196 if _, ok := rawArgs["first"]; !ok {
197 var zeroVal *int
198 return zeroVal, nil
199 }
200
201 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
202 if tmp, ok := rawArgs["first"]; ok {
203 return ec.unmarshalOInt2ᚖint(ctx, tmp)
204 }
205
206 var zeroVal *int
207 return zeroVal, nil
208}
209
210func (ec *executionContext) field_Board_columns_argsLast(
211 ctx context.Context,
212 rawArgs map[string]any,
213) (*int, error) {
214 if _, ok := rawArgs["last"]; !ok {
215 var zeroVal *int
216 return zeroVal, nil
217 }
218
219 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
220 if tmp, ok := rawArgs["last"]; ok {
221 return ec.unmarshalOInt2ᚖint(ctx, tmp)
222 }
223
224 var zeroVal *int
225 return zeroVal, nil
226}
227
228func (ec *executionContext) field_Board_operations_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
229 var err error
230 args := map[string]any{}
231 arg0, err := ec.field_Board_operations_argsAfter(ctx, rawArgs)
232 if err != nil {
233 return nil, err
234 }
235 args["after"] = arg0
236 arg1, err := ec.field_Board_operations_argsBefore(ctx, rawArgs)
237 if err != nil {
238 return nil, err
239 }
240 args["before"] = arg1
241 arg2, err := ec.field_Board_operations_argsFirst(ctx, rawArgs)
242 if err != nil {
243 return nil, err
244 }
245 args["first"] = arg2
246 arg3, err := ec.field_Board_operations_argsLast(ctx, rawArgs)
247 if err != nil {
248 return nil, err
249 }
250 args["last"] = arg3
251 return args, nil
252}
253func (ec *executionContext) field_Board_operations_argsAfter(
254 ctx context.Context,
255 rawArgs map[string]any,
256) (*string, error) {
257 if _, ok := rawArgs["after"]; !ok {
258 var zeroVal *string
259 return zeroVal, nil
260 }
261
262 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
263 if tmp, ok := rawArgs["after"]; ok {
264 return ec.unmarshalOString2ᚖstring(ctx, tmp)
265 }
266
267 var zeroVal *string
268 return zeroVal, nil
269}
270
271func (ec *executionContext) field_Board_operations_argsBefore(
272 ctx context.Context,
273 rawArgs map[string]any,
274) (*string, error) {
275 if _, ok := rawArgs["before"]; !ok {
276 var zeroVal *string
277 return zeroVal, nil
278 }
279
280 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
281 if tmp, ok := rawArgs["before"]; ok {
282 return ec.unmarshalOString2ᚖstring(ctx, tmp)
283 }
284
285 var zeroVal *string
286 return zeroVal, nil
287}
288
289func (ec *executionContext) field_Board_operations_argsFirst(
290 ctx context.Context,
291 rawArgs map[string]any,
292) (*int, error) {
293 if _, ok := rawArgs["first"]; !ok {
294 var zeroVal *int
295 return zeroVal, nil
296 }
297
298 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
299 if tmp, ok := rawArgs["first"]; ok {
300 return ec.unmarshalOInt2ᚖint(ctx, tmp)
301 }
302
303 var zeroVal *int
304 return zeroVal, nil
305}
306
307func (ec *executionContext) field_Board_operations_argsLast(
308 ctx context.Context,
309 rawArgs map[string]any,
310) (*int, error) {
311 if _, ok := rawArgs["last"]; !ok {
312 var zeroVal *int
313 return zeroVal, nil
314 }
315
316 ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
317 if tmp, ok := rawArgs["last"]; ok {
318 return ec.unmarshalOInt2ᚖint(ctx, tmp)
319 }
320
321 var zeroVal *int
322 return zeroVal, nil
323}
324
325// endregion ***************************** args.gotpl *****************************
326
327// region ************************** directives.gotpl **************************
328
329// endregion ************************** directives.gotpl **************************
330
331// region **************************** field.gotpl *****************************
332
333func (ec *executionContext) _Board_id(ctx context.Context, field graphql.CollectedField, obj models.BoardWrapper) (ret graphql.Marshaler) {
334 fc, err := ec.fieldContext_Board_id(ctx, field)
335 if err != nil {
336 return graphql.Null
337 }
338 ctx = graphql.WithFieldContext(ctx, fc)
339 defer func() {
340 if r := recover(); r != nil {
341 ec.Error(ctx, ec.Recover(ctx, r))
342 ret = graphql.Null
343 }
344 }()
345 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
346 ctx = rctx // use context from middleware stack in children
347 return obj.Id(), nil
348 })
349 if err != nil {
350 ec.Error(ctx, err)
351 return graphql.Null
352 }
353 if resTmp == nil {
354 if !graphql.HasFieldError(ctx, fc) {
355 ec.Errorf(ctx, "must not be null")
356 }
357 return graphql.Null
358 }
359 res := resTmp.(entity.Id)
360 fc.Result = res
361 return ec.marshalNID2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐId(ctx, field.Selections, res)
362}
363
364func (ec *executionContext) fieldContext_Board_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
365 fc = &graphql.FieldContext{
366 Object: "Board",
367 Field: field,
368 IsMethod: true,
369 IsResolver: false,
370 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
371 return nil, errors.New("field of type ID does not have child fields")
372 },
373 }
374 return fc, nil
375}
376
377func (ec *executionContext) _Board_humanId(ctx context.Context, field graphql.CollectedField, obj models.BoardWrapper) (ret graphql.Marshaler) {
378 fc, err := ec.fieldContext_Board_humanId(ctx, field)
379 if err != nil {
380 return graphql.Null
381 }
382 ctx = graphql.WithFieldContext(ctx, fc)
383 defer func() {
384 if r := recover(); r != nil {
385 ec.Error(ctx, ec.Recover(ctx, r))
386 ret = graphql.Null
387 }
388 }()
389 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
390 ctx = rctx // use context from middleware stack in children
391 return ec.resolvers.Board().HumanID(rctx, obj)
392 })
393 if err != nil {
394 ec.Error(ctx, err)
395 return graphql.Null
396 }
397 if resTmp == nil {
398 if !graphql.HasFieldError(ctx, fc) {
399 ec.Errorf(ctx, "must not be null")
400 }
401 return graphql.Null
402 }
403 res := resTmp.(string)
404 fc.Result = res
405 return ec.marshalNString2string(ctx, field.Selections, res)
406}
407
408func (ec *executionContext) fieldContext_Board_humanId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
409 fc = &graphql.FieldContext{
410 Object: "Board",
411 Field: field,
412 IsMethod: true,
413 IsResolver: true,
414 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
415 return nil, errors.New("field of type String does not have child fields")
416 },
417 }
418 return fc, nil
419}
420
421func (ec *executionContext) _Board_createdAt(ctx context.Context, field graphql.CollectedField, obj models.BoardWrapper) (ret graphql.Marshaler) {
422 fc, err := ec.fieldContext_Board_createdAt(ctx, field)
423 if err != nil {
424 return graphql.Null
425 }
426 ctx = graphql.WithFieldContext(ctx, fc)
427 defer func() {
428 if r := recover(); r != nil {
429 ec.Error(ctx, ec.Recover(ctx, r))
430 ret = graphql.Null
431 }
432 }()
433 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
434 ctx = rctx // use context from middleware stack in children
435 return obj.CreatedAt(), nil
436 })
437 if err != nil {
438 ec.Error(ctx, err)
439 return graphql.Null
440 }
441 if resTmp == nil {
442 if !graphql.HasFieldError(ctx, fc) {
443 ec.Errorf(ctx, "must not be null")
444 }
445 return graphql.Null
446 }
447 res := resTmp.(time.Time)
448 fc.Result = res
449 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
450}
451
452func (ec *executionContext) fieldContext_Board_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
453 fc = &graphql.FieldContext{
454 Object: "Board",
455 Field: field,
456 IsMethod: true,
457 IsResolver: false,
458 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
459 return nil, errors.New("field of type Time does not have child fields")
460 },
461 }
462 return fc, nil
463}
464
465func (ec *executionContext) _Board_lastEdit(ctx context.Context, field graphql.CollectedField, obj models.BoardWrapper) (ret graphql.Marshaler) {
466 fc, err := ec.fieldContext_Board_lastEdit(ctx, field)
467 if err != nil {
468 return graphql.Null
469 }
470 ctx = graphql.WithFieldContext(ctx, fc)
471 defer func() {
472 if r := recover(); r != nil {
473 ec.Error(ctx, ec.Recover(ctx, r))
474 ret = graphql.Null
475 }
476 }()
477 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
478 ctx = rctx // use context from middleware stack in children
479 return obj.LastEdit(), nil
480 })
481 if err != nil {
482 ec.Error(ctx, err)
483 return graphql.Null
484 }
485 if resTmp == nil {
486 if !graphql.HasFieldError(ctx, fc) {
487 ec.Errorf(ctx, "must not be null")
488 }
489 return graphql.Null
490 }
491 res := resTmp.(time.Time)
492 fc.Result = res
493 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
494}
495
496func (ec *executionContext) fieldContext_Board_lastEdit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
497 fc = &graphql.FieldContext{
498 Object: "Board",
499 Field: field,
500 IsMethod: true,
501 IsResolver: false,
502 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
503 return nil, errors.New("field of type Time does not have child fields")
504 },
505 }
506 return fc, nil
507}
508
509func (ec *executionContext) _Board_title(ctx context.Context, field graphql.CollectedField, obj models.BoardWrapper) (ret graphql.Marshaler) {
510 fc, err := ec.fieldContext_Board_title(ctx, field)
511 if err != nil {
512 return graphql.Null
513 }
514 ctx = graphql.WithFieldContext(ctx, fc)
515 defer func() {
516 if r := recover(); r != nil {
517 ec.Error(ctx, ec.Recover(ctx, r))
518 ret = graphql.Null
519 }
520 }()
521 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
522 ctx = rctx // use context from middleware stack in children
523 return obj.Title(), nil
524 })
525 if err != nil {
526 ec.Error(ctx, err)
527 return graphql.Null
528 }
529 if resTmp == nil {
530 if !graphql.HasFieldError(ctx, fc) {
531 ec.Errorf(ctx, "must not be null")
532 }
533 return graphql.Null
534 }
535 res := resTmp.(string)
536 fc.Result = res
537 return ec.marshalNString2string(ctx, field.Selections, res)
538}
539
540func (ec *executionContext) fieldContext_Board_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
541 fc = &graphql.FieldContext{
542 Object: "Board",
543 Field: field,
544 IsMethod: true,
545 IsResolver: false,
546 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
547 return nil, errors.New("field of type String does not have child fields")
548 },
549 }
550 return fc, nil
551}
552
553func (ec *executionContext) _Board_description(ctx context.Context, field graphql.CollectedField, obj models.BoardWrapper) (ret graphql.Marshaler) {
554 fc, err := ec.fieldContext_Board_description(ctx, field)
555 if err != nil {
556 return graphql.Null
557 }
558 ctx = graphql.WithFieldContext(ctx, fc)
559 defer func() {
560 if r := recover(); r != nil {
561 ec.Error(ctx, ec.Recover(ctx, r))
562 ret = graphql.Null
563 }
564 }()
565 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
566 ctx = rctx // use context from middleware stack in children
567 return obj.Description(), nil
568 })
569 if err != nil {
570 ec.Error(ctx, err)
571 return graphql.Null
572 }
573 if resTmp == nil {
574 if !graphql.HasFieldError(ctx, fc) {
575 ec.Errorf(ctx, "must not be null")
576 }
577 return graphql.Null
578 }
579 res := resTmp.(string)
580 fc.Result = res
581 return ec.marshalNString2string(ctx, field.Selections, res)
582}
583
584func (ec *executionContext) fieldContext_Board_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
585 fc = &graphql.FieldContext{
586 Object: "Board",
587 Field: field,
588 IsMethod: true,
589 IsResolver: false,
590 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
591 return nil, errors.New("field of type String does not have child fields")
592 },
593 }
594 return fc, nil
595}
596
597func (ec *executionContext) _Board_columns(ctx context.Context, field graphql.CollectedField, obj models.BoardWrapper) (ret graphql.Marshaler) {
598 fc, err := ec.fieldContext_Board_columns(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.Board().Columns(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.BoardColumnConnection)
624 fc.Result = res
625 return ec.marshalNBoardColumnConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBoardColumnConnection(ctx, field.Selections, res)
626}
627
628func (ec *executionContext) fieldContext_Board_columns(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
629 fc = &graphql.FieldContext{
630 Object: "Board",
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_BoardColumnConnection_edges(ctx, field)
638 case "nodes":
639 return ec.fieldContext_BoardColumnConnection_nodes(ctx, field)
640 case "pageInfo":
641 return ec.fieldContext_BoardColumnConnection_pageInfo(ctx, field)
642 case "totalCount":
643 return ec.fieldContext_BoardColumnConnection_totalCount(ctx, field)
644 }
645 return nil, fmt.Errorf("no field named %q was found under type BoardColumnConnection", 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_Board_columns_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) _Board_actors(ctx context.Context, field graphql.CollectedField, obj models.BoardWrapper) (ret graphql.Marshaler) {
663 fc, err := ec.fieldContext_Board_actors(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.Board().Actors(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
677 })
678 if err != nil {
679 ec.Error(ctx, err)
680 return graphql.Null
681 }
682 if resTmp == nil {
683 if !graphql.HasFieldError(ctx, fc) {
684 ec.Errorf(ctx, "must not be null")
685 }
686 return graphql.Null
687 }
688 res := resTmp.(*models.IdentityConnection)
689 fc.Result = res
690 return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
691}
692
693func (ec *executionContext) fieldContext_Board_actors(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
694 fc = &graphql.FieldContext{
695 Object: "Board",
696 Field: field,
697 IsMethod: true,
698 IsResolver: true,
699 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
700 switch field.Name {
701 case "edges":
702 return ec.fieldContext_IdentityConnection_edges(ctx, field)
703 case "nodes":
704 return ec.fieldContext_IdentityConnection_nodes(ctx, field)
705 case "pageInfo":
706 return ec.fieldContext_IdentityConnection_pageInfo(ctx, field)
707 case "totalCount":
708 return ec.fieldContext_IdentityConnection_totalCount(ctx, field)
709 }
710 return nil, fmt.Errorf("no field named %q was found under type IdentityConnection", field.Name)
711 },
712 }
713 defer func() {
714 if r := recover(); r != nil {
715 err = ec.Recover(ctx, r)
716 ec.Error(ctx, err)
717 }
718 }()
719 ctx = graphql.WithFieldContext(ctx, fc)
720 if fc.Args, err = ec.field_Board_actors_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
721 ec.Error(ctx, err)
722 return fc, err
723 }
724 return fc, nil
725}
726
727func (ec *executionContext) _Board_operations(ctx context.Context, field graphql.CollectedField, obj models.BoardWrapper) (ret graphql.Marshaler) {
728 fc, err := ec.fieldContext_Board_operations(ctx, field)
729 if err != nil {
730 return graphql.Null
731 }
732 ctx = graphql.WithFieldContext(ctx, fc)
733 defer func() {
734 if r := recover(); r != nil {
735 ec.Error(ctx, ec.Recover(ctx, r))
736 ret = graphql.Null
737 }
738 }()
739 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
740 ctx = rctx // use context from middleware stack in children
741 return ec.resolvers.Board().Operations(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
742 })
743 if err != nil {
744 ec.Error(ctx, err)
745 return graphql.Null
746 }
747 if resTmp == nil {
748 if !graphql.HasFieldError(ctx, fc) {
749 ec.Errorf(ctx, "must not be null")
750 }
751 return graphql.Null
752 }
753 res := resTmp.(*models.OperationConnection)
754 fc.Result = res
755 return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
756}
757
758func (ec *executionContext) fieldContext_Board_operations(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
759 fc = &graphql.FieldContext{
760 Object: "Board",
761 Field: field,
762 IsMethod: true,
763 IsResolver: true,
764 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
765 switch field.Name {
766 case "edges":
767 return ec.fieldContext_OperationConnection_edges(ctx, field)
768 case "nodes":
769 return ec.fieldContext_OperationConnection_nodes(ctx, field)
770 case "pageInfo":
771 return ec.fieldContext_OperationConnection_pageInfo(ctx, field)
772 case "totalCount":
773 return ec.fieldContext_OperationConnection_totalCount(ctx, field)
774 }
775 return nil, fmt.Errorf("no field named %q was found under type OperationConnection", field.Name)
776 },
777 }
778 defer func() {
779 if r := recover(); r != nil {
780 err = ec.Recover(ctx, r)
781 ec.Error(ctx, err)
782 }
783 }()
784 ctx = graphql.WithFieldContext(ctx, fc)
785 if fc.Args, err = ec.field_Board_operations_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
786 ec.Error(ctx, err)
787 return fc, err
788 }
789 return fc, nil
790}
791
792func (ec *executionContext) _BoardConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BoardConnection) (ret graphql.Marshaler) {
793 fc, err := ec.fieldContext_BoardConnection_edges(ctx, field)
794 if err != nil {
795 return graphql.Null
796 }
797 ctx = graphql.WithFieldContext(ctx, fc)
798 defer func() {
799 if r := recover(); r != nil {
800 ec.Error(ctx, ec.Recover(ctx, r))
801 ret = graphql.Null
802 }
803 }()
804 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
805 ctx = rctx // use context from middleware stack in children
806 return obj.Edges, nil
807 })
808 if err != nil {
809 ec.Error(ctx, err)
810 return graphql.Null
811 }
812 if resTmp == nil {
813 if !graphql.HasFieldError(ctx, fc) {
814 ec.Errorf(ctx, "must not be null")
815 }
816 return graphql.Null
817 }
818 res := resTmp.([]*models.BoardEdge)
819 fc.Result = res
820 return ec.marshalNBoardEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBoardEdgeᚄ(ctx, field.Selections, res)
821}
822
823func (ec *executionContext) fieldContext_BoardConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
824 fc = &graphql.FieldContext{
825 Object: "BoardConnection",
826 Field: field,
827 IsMethod: false,
828 IsResolver: false,
829 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
830 switch field.Name {
831 case "cursor":
832 return ec.fieldContext_BoardEdge_cursor(ctx, field)
833 case "node":
834 return ec.fieldContext_BoardEdge_node(ctx, field)
835 }
836 return nil, fmt.Errorf("no field named %q was found under type BoardEdge", field.Name)
837 },
838 }
839 return fc, nil
840}
841
842func (ec *executionContext) _BoardConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BoardConnection) (ret graphql.Marshaler) {
843 fc, err := ec.fieldContext_BoardConnection_nodes(ctx, field)
844 if err != nil {
845 return graphql.Null
846 }
847 ctx = graphql.WithFieldContext(ctx, fc)
848 defer func() {
849 if r := recover(); r != nil {
850 ec.Error(ctx, ec.Recover(ctx, r))
851 ret = graphql.Null
852 }
853 }()
854 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
855 ctx = rctx // use context from middleware stack in children
856 return obj.Nodes, nil
857 })
858 if err != nil {
859 ec.Error(ctx, err)
860 return graphql.Null
861 }
862 if resTmp == nil {
863 if !graphql.HasFieldError(ctx, fc) {
864 ec.Errorf(ctx, "must not be null")
865 }
866 return graphql.Null
867 }
868 res := resTmp.([]models.BoardWrapper)
869 fc.Result = res
870 return ec.marshalNBoard2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBoardWrapperᚄ(ctx, field.Selections, res)
871}
872
873func (ec *executionContext) fieldContext_BoardConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
874 fc = &graphql.FieldContext{
875 Object: "BoardConnection",
876 Field: field,
877 IsMethod: false,
878 IsResolver: false,
879 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
880 switch field.Name {
881 case "id":
882 return ec.fieldContext_Board_id(ctx, field)
883 case "humanId":
884 return ec.fieldContext_Board_humanId(ctx, field)
885 case "createdAt":
886 return ec.fieldContext_Board_createdAt(ctx, field)
887 case "lastEdit":
888 return ec.fieldContext_Board_lastEdit(ctx, field)
889 case "title":
890 return ec.fieldContext_Board_title(ctx, field)
891 case "description":
892 return ec.fieldContext_Board_description(ctx, field)
893 case "columns":
894 return ec.fieldContext_Board_columns(ctx, field)
895 case "actors":
896 return ec.fieldContext_Board_actors(ctx, field)
897 case "operations":
898 return ec.fieldContext_Board_operations(ctx, field)
899 }
900 return nil, fmt.Errorf("no field named %q was found under type Board", field.Name)
901 },
902 }
903 return fc, nil
904}
905
906func (ec *executionContext) _BoardConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BoardConnection) (ret graphql.Marshaler) {
907 fc, err := ec.fieldContext_BoardConnection_pageInfo(ctx, field)
908 if err != nil {
909 return graphql.Null
910 }
911 ctx = graphql.WithFieldContext(ctx, fc)
912 defer func() {
913 if r := recover(); r != nil {
914 ec.Error(ctx, ec.Recover(ctx, r))
915 ret = graphql.Null
916 }
917 }()
918 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
919 ctx = rctx // use context from middleware stack in children
920 return obj.PageInfo, nil
921 })
922 if err != nil {
923 ec.Error(ctx, err)
924 return graphql.Null
925 }
926 if resTmp == nil {
927 if !graphql.HasFieldError(ctx, fc) {
928 ec.Errorf(ctx, "must not be null")
929 }
930 return graphql.Null
931 }
932 res := resTmp.(*models.PageInfo)
933 fc.Result = res
934 return ec.marshalNPageInfo2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
935}
936
937func (ec *executionContext) fieldContext_BoardConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
938 fc = &graphql.FieldContext{
939 Object: "BoardConnection",
940 Field: field,
941 IsMethod: false,
942 IsResolver: false,
943 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
944 switch field.Name {
945 case "hasNextPage":
946 return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
947 case "hasPreviousPage":
948 return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
949 case "startCursor":
950 return ec.fieldContext_PageInfo_startCursor(ctx, field)
951 case "endCursor":
952 return ec.fieldContext_PageInfo_endCursor(ctx, field)
953 }
954 return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
955 },
956 }
957 return fc, nil
958}
959
960func (ec *executionContext) _BoardConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BoardConnection) (ret graphql.Marshaler) {
961 fc, err := ec.fieldContext_BoardConnection_totalCount(ctx, field)
962 if err != nil {
963 return graphql.Null
964 }
965 ctx = graphql.WithFieldContext(ctx, fc)
966 defer func() {
967 if r := recover(); r != nil {
968 ec.Error(ctx, ec.Recover(ctx, r))
969 ret = graphql.Null
970 }
971 }()
972 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
973 ctx = rctx // use context from middleware stack in children
974 return obj.TotalCount, nil
975 })
976 if err != nil {
977 ec.Error(ctx, err)
978 return graphql.Null
979 }
980 if resTmp == nil {
981 if !graphql.HasFieldError(ctx, fc) {
982 ec.Errorf(ctx, "must not be null")
983 }
984 return graphql.Null
985 }
986 res := resTmp.(int)
987 fc.Result = res
988 return ec.marshalNInt2int(ctx, field.Selections, res)
989}
990
991func (ec *executionContext) fieldContext_BoardConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
992 fc = &graphql.FieldContext{
993 Object: "BoardConnection",
994 Field: field,
995 IsMethod: false,
996 IsResolver: false,
997 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
998 return nil, errors.New("field of type Int does not have child fields")
999 },
1000 }
1001 return fc, nil
1002}
1003
1004func (ec *executionContext) _BoardEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BoardEdge) (ret graphql.Marshaler) {
1005 fc, err := ec.fieldContext_BoardEdge_cursor(ctx, field)
1006 if err != nil {
1007 return graphql.Null
1008 }
1009 ctx = graphql.WithFieldContext(ctx, fc)
1010 defer func() {
1011 if r := recover(); r != nil {
1012 ec.Error(ctx, ec.Recover(ctx, r))
1013 ret = graphql.Null
1014 }
1015 }()
1016 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1017 ctx = rctx // use context from middleware stack in children
1018 return obj.Cursor, nil
1019 })
1020 if err != nil {
1021 ec.Error(ctx, err)
1022 return graphql.Null
1023 }
1024 if resTmp == nil {
1025 if !graphql.HasFieldError(ctx, fc) {
1026 ec.Errorf(ctx, "must not be null")
1027 }
1028 return graphql.Null
1029 }
1030 res := resTmp.(string)
1031 fc.Result = res
1032 return ec.marshalNString2string(ctx, field.Selections, res)
1033}
1034
1035func (ec *executionContext) fieldContext_BoardEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1036 fc = &graphql.FieldContext{
1037 Object: "BoardEdge",
1038 Field: field,
1039 IsMethod: false,
1040 IsResolver: false,
1041 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1042 return nil, errors.New("field of type String does not have child fields")
1043 },
1044 }
1045 return fc, nil
1046}
1047
1048func (ec *executionContext) _BoardEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BoardEdge) (ret graphql.Marshaler) {
1049 fc, err := ec.fieldContext_BoardEdge_node(ctx, field)
1050 if err != nil {
1051 return graphql.Null
1052 }
1053 ctx = graphql.WithFieldContext(ctx, fc)
1054 defer func() {
1055 if r := recover(); r != nil {
1056 ec.Error(ctx, ec.Recover(ctx, r))
1057 ret = graphql.Null
1058 }
1059 }()
1060 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1061 ctx = rctx // use context from middleware stack in children
1062 return obj.Node, nil
1063 })
1064 if err != nil {
1065 ec.Error(ctx, err)
1066 return graphql.Null
1067 }
1068 if resTmp == nil {
1069 if !graphql.HasFieldError(ctx, fc) {
1070 ec.Errorf(ctx, "must not be null")
1071 }
1072 return graphql.Null
1073 }
1074 res := resTmp.(models.BoardWrapper)
1075 fc.Result = res
1076 return ec.marshalNBoard2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBoardWrapper(ctx, field.Selections, res)
1077}
1078
1079func (ec *executionContext) fieldContext_BoardEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1080 fc = &graphql.FieldContext{
1081 Object: "BoardEdge",
1082 Field: field,
1083 IsMethod: false,
1084 IsResolver: false,
1085 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1086 switch field.Name {
1087 case "id":
1088 return ec.fieldContext_Board_id(ctx, field)
1089 case "humanId":
1090 return ec.fieldContext_Board_humanId(ctx, field)
1091 case "createdAt":
1092 return ec.fieldContext_Board_createdAt(ctx, field)
1093 case "lastEdit":
1094 return ec.fieldContext_Board_lastEdit(ctx, field)
1095 case "title":
1096 return ec.fieldContext_Board_title(ctx, field)
1097 case "description":
1098 return ec.fieldContext_Board_description(ctx, field)
1099 case "columns":
1100 return ec.fieldContext_Board_columns(ctx, field)
1101 case "actors":
1102 return ec.fieldContext_Board_actors(ctx, field)
1103 case "operations":
1104 return ec.fieldContext_Board_operations(ctx, field)
1105 }
1106 return nil, fmt.Errorf("no field named %q was found under type Board", field.Name)
1107 },
1108 }
1109 return fc, nil
1110}
1111
1112// endregion **************************** field.gotpl *****************************
1113
1114// region **************************** input.gotpl *****************************
1115
1116// endregion **************************** input.gotpl *****************************
1117
1118// region ************************** interface.gotpl ***************************
1119
1120// endregion ************************** interface.gotpl ***************************
1121
1122// region **************************** object.gotpl ****************************
1123
1124var boardImplementors = []string{"Board"}
1125
1126func (ec *executionContext) _Board(ctx context.Context, sel ast.SelectionSet, obj models.BoardWrapper) graphql.Marshaler {
1127 fields := graphql.CollectFields(ec.OperationContext, sel, boardImplementors)
1128
1129 out := graphql.NewFieldSet(fields)
1130 deferred := make(map[string]*graphql.FieldSet)
1131 for i, field := range fields {
1132 switch field.Name {
1133 case "__typename":
1134 out.Values[i] = graphql.MarshalString("Board")
1135 case "id":
1136 out.Values[i] = ec._Board_id(ctx, field, obj)
1137 if out.Values[i] == graphql.Null {
1138 atomic.AddUint32(&out.Invalids, 1)
1139 }
1140 case "humanId":
1141 field := field
1142
1143 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1144 defer func() {
1145 if r := recover(); r != nil {
1146 ec.Error(ctx, ec.Recover(ctx, r))
1147 }
1148 }()
1149 res = ec._Board_humanId(ctx, field, obj)
1150 if res == graphql.Null {
1151 atomic.AddUint32(&fs.Invalids, 1)
1152 }
1153 return res
1154 }
1155
1156 if field.Deferrable != nil {
1157 dfs, ok := deferred[field.Deferrable.Label]
1158 di := 0
1159 if ok {
1160 dfs.AddField(field)
1161 di = len(dfs.Values) - 1
1162 } else {
1163 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1164 deferred[field.Deferrable.Label] = dfs
1165 }
1166 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1167 return innerFunc(ctx, dfs)
1168 })
1169
1170 // don't run the out.Concurrently() call below
1171 out.Values[i] = graphql.Null
1172 continue
1173 }
1174
1175 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1176 case "createdAt":
1177 out.Values[i] = ec._Board_createdAt(ctx, field, obj)
1178 if out.Values[i] == graphql.Null {
1179 atomic.AddUint32(&out.Invalids, 1)
1180 }
1181 case "lastEdit":
1182 out.Values[i] = ec._Board_lastEdit(ctx, field, obj)
1183 if out.Values[i] == graphql.Null {
1184 atomic.AddUint32(&out.Invalids, 1)
1185 }
1186 case "title":
1187 out.Values[i] = ec._Board_title(ctx, field, obj)
1188 if out.Values[i] == graphql.Null {
1189 atomic.AddUint32(&out.Invalids, 1)
1190 }
1191 case "description":
1192 out.Values[i] = ec._Board_description(ctx, field, obj)
1193 if out.Values[i] == graphql.Null {
1194 atomic.AddUint32(&out.Invalids, 1)
1195 }
1196 case "columns":
1197 field := field
1198
1199 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1200 defer func() {
1201 if r := recover(); r != nil {
1202 ec.Error(ctx, ec.Recover(ctx, r))
1203 }
1204 }()
1205 res = ec._Board_columns(ctx, field, obj)
1206 if res == graphql.Null {
1207 atomic.AddUint32(&fs.Invalids, 1)
1208 }
1209 return res
1210 }
1211
1212 if field.Deferrable != nil {
1213 dfs, ok := deferred[field.Deferrable.Label]
1214 di := 0
1215 if ok {
1216 dfs.AddField(field)
1217 di = len(dfs.Values) - 1
1218 } else {
1219 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1220 deferred[field.Deferrable.Label] = dfs
1221 }
1222 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1223 return innerFunc(ctx, dfs)
1224 })
1225
1226 // don't run the out.Concurrently() call below
1227 out.Values[i] = graphql.Null
1228 continue
1229 }
1230
1231 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1232 case "actors":
1233 field := field
1234
1235 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1236 defer func() {
1237 if r := recover(); r != nil {
1238 ec.Error(ctx, ec.Recover(ctx, r))
1239 }
1240 }()
1241 res = ec._Board_actors(ctx, field, obj)
1242 if res == graphql.Null {
1243 atomic.AddUint32(&fs.Invalids, 1)
1244 }
1245 return res
1246 }
1247
1248 if field.Deferrable != nil {
1249 dfs, ok := deferred[field.Deferrable.Label]
1250 di := 0
1251 if ok {
1252 dfs.AddField(field)
1253 di = len(dfs.Values) - 1
1254 } else {
1255 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1256 deferred[field.Deferrable.Label] = dfs
1257 }
1258 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1259 return innerFunc(ctx, dfs)
1260 })
1261
1262 // don't run the out.Concurrently() call below
1263 out.Values[i] = graphql.Null
1264 continue
1265 }
1266
1267 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1268 case "operations":
1269 field := field
1270
1271 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1272 defer func() {
1273 if r := recover(); r != nil {
1274 ec.Error(ctx, ec.Recover(ctx, r))
1275 }
1276 }()
1277 res = ec._Board_operations(ctx, field, obj)
1278 if res == graphql.Null {
1279 atomic.AddUint32(&fs.Invalids, 1)
1280 }
1281 return res
1282 }
1283
1284 if field.Deferrable != nil {
1285 dfs, ok := deferred[field.Deferrable.Label]
1286 di := 0
1287 if ok {
1288 dfs.AddField(field)
1289 di = len(dfs.Values) - 1
1290 } else {
1291 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1292 deferred[field.Deferrable.Label] = dfs
1293 }
1294 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1295 return innerFunc(ctx, dfs)
1296 })
1297
1298 // don't run the out.Concurrently() call below
1299 out.Values[i] = graphql.Null
1300 continue
1301 }
1302
1303 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1304 default:
1305 panic("unknown field " + strconv.Quote(field.Name))
1306 }
1307 }
1308 out.Dispatch(ctx)
1309 if out.Invalids > 0 {
1310 return graphql.Null
1311 }
1312
1313 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1314
1315 for label, dfs := range deferred {
1316 ec.processDeferredGroup(graphql.DeferredGroup{
1317 Label: label,
1318 Path: graphql.GetPath(ctx),
1319 FieldSet: dfs,
1320 Context: ctx,
1321 })
1322 }
1323
1324 return out
1325}
1326
1327var boardConnectionImplementors = []string{"BoardConnection"}
1328
1329func (ec *executionContext) _BoardConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BoardConnection) graphql.Marshaler {
1330 fields := graphql.CollectFields(ec.OperationContext, sel, boardConnectionImplementors)
1331
1332 out := graphql.NewFieldSet(fields)
1333 deferred := make(map[string]*graphql.FieldSet)
1334 for i, field := range fields {
1335 switch field.Name {
1336 case "__typename":
1337 out.Values[i] = graphql.MarshalString("BoardConnection")
1338 case "edges":
1339 out.Values[i] = ec._BoardConnection_edges(ctx, field, obj)
1340 if out.Values[i] == graphql.Null {
1341 out.Invalids++
1342 }
1343 case "nodes":
1344 out.Values[i] = ec._BoardConnection_nodes(ctx, field, obj)
1345 if out.Values[i] == graphql.Null {
1346 out.Invalids++
1347 }
1348 case "pageInfo":
1349 out.Values[i] = ec._BoardConnection_pageInfo(ctx, field, obj)
1350 if out.Values[i] == graphql.Null {
1351 out.Invalids++
1352 }
1353 case "totalCount":
1354 out.Values[i] = ec._BoardConnection_totalCount(ctx, field, obj)
1355 if out.Values[i] == graphql.Null {
1356 out.Invalids++
1357 }
1358 default:
1359 panic("unknown field " + strconv.Quote(field.Name))
1360 }
1361 }
1362 out.Dispatch(ctx)
1363 if out.Invalids > 0 {
1364 return graphql.Null
1365 }
1366
1367 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1368
1369 for label, dfs := range deferred {
1370 ec.processDeferredGroup(graphql.DeferredGroup{
1371 Label: label,
1372 Path: graphql.GetPath(ctx),
1373 FieldSet: dfs,
1374 Context: ctx,
1375 })
1376 }
1377
1378 return out
1379}
1380
1381var boardEdgeImplementors = []string{"BoardEdge"}
1382
1383func (ec *executionContext) _BoardEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BoardEdge) graphql.Marshaler {
1384 fields := graphql.CollectFields(ec.OperationContext, sel, boardEdgeImplementors)
1385
1386 out := graphql.NewFieldSet(fields)
1387 deferred := make(map[string]*graphql.FieldSet)
1388 for i, field := range fields {
1389 switch field.Name {
1390 case "__typename":
1391 out.Values[i] = graphql.MarshalString("BoardEdge")
1392 case "cursor":
1393 out.Values[i] = ec._BoardEdge_cursor(ctx, field, obj)
1394 if out.Values[i] == graphql.Null {
1395 out.Invalids++
1396 }
1397 case "node":
1398 out.Values[i] = ec._BoardEdge_node(ctx, field, obj)
1399 if out.Values[i] == graphql.Null {
1400 out.Invalids++
1401 }
1402 default:
1403 panic("unknown field " + strconv.Quote(field.Name))
1404 }
1405 }
1406 out.Dispatch(ctx)
1407 if out.Invalids > 0 {
1408 return graphql.Null
1409 }
1410
1411 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1412
1413 for label, dfs := range deferred {
1414 ec.processDeferredGroup(graphql.DeferredGroup{
1415 Label: label,
1416 Path: graphql.GetPath(ctx),
1417 FieldSet: dfs,
1418 Context: ctx,
1419 })
1420 }
1421
1422 return out
1423}
1424
1425// endregion **************************** object.gotpl ****************************
1426
1427// region ***************************** type.gotpl *****************************
1428
1429func (ec *executionContext) marshalNBoard2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBoardWrapper(ctx context.Context, sel ast.SelectionSet, v models.BoardWrapper) graphql.Marshaler {
1430 if v == nil {
1431 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
1432 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
1433 }
1434 return graphql.Null
1435 }
1436 return ec._Board(ctx, sel, v)
1437}
1438
1439func (ec *executionContext) marshalNBoard2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBoardWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BoardWrapper) graphql.Marshaler {
1440 ret := make(graphql.Array, len(v))
1441 var wg sync.WaitGroup
1442 isLen1 := len(v) == 1
1443 if !isLen1 {
1444 wg.Add(len(v))
1445 }
1446 for i := range v {
1447 i := i
1448 fc := &graphql.FieldContext{
1449 Index: &i,
1450 Result: &v[i],
1451 }
1452 ctx := graphql.WithFieldContext(ctx, fc)
1453 f := func(i int) {
1454 defer func() {
1455 if r := recover(); r != nil {
1456 ec.Error(ctx, ec.Recover(ctx, r))
1457 ret = nil
1458 }
1459 }()
1460 if !isLen1 {
1461 defer wg.Done()
1462 }
1463 ret[i] = ec.marshalNBoard2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBoardWrapper(ctx, sel, v[i])
1464 }
1465 if isLen1 {
1466 f(i)
1467 } else {
1468 go f(i)
1469 }
1470
1471 }
1472 wg.Wait()
1473
1474 for _, e := range ret {
1475 if e == graphql.Null {
1476 return graphql.Null
1477 }
1478 }
1479
1480 return ret
1481}
1482
1483func (ec *executionContext) marshalNBoardEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBoardEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BoardEdge) graphql.Marshaler {
1484 ret := make(graphql.Array, len(v))
1485 var wg sync.WaitGroup
1486 isLen1 := len(v) == 1
1487 if !isLen1 {
1488 wg.Add(len(v))
1489 }
1490 for i := range v {
1491 i := i
1492 fc := &graphql.FieldContext{
1493 Index: &i,
1494 Result: &v[i],
1495 }
1496 ctx := graphql.WithFieldContext(ctx, fc)
1497 f := func(i int) {
1498 defer func() {
1499 if r := recover(); r != nil {
1500 ec.Error(ctx, ec.Recover(ctx, r))
1501 ret = nil
1502 }
1503 }()
1504 if !isLen1 {
1505 defer wg.Done()
1506 }
1507 ret[i] = ec.marshalNBoardEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBoardEdge(ctx, sel, v[i])
1508 }
1509 if isLen1 {
1510 f(i)
1511 } else {
1512 go f(i)
1513 }
1514
1515 }
1516 wg.Wait()
1517
1518 for _, e := range ret {
1519 if e == graphql.Null {
1520 return graphql.Null
1521 }
1522 }
1523
1524 return ret
1525}
1526
1527func (ec *executionContext) marshalNBoardEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBoardEdge(ctx context.Context, sel ast.SelectionSet, v *models.BoardEdge) graphql.Marshaler {
1528 if v == nil {
1529 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
1530 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
1531 }
1532 return graphql.Null
1533 }
1534 return ec._BoardEdge(ctx, sel, v)
1535}
1536
1537// endregion ***************************** type.gotpl *****************************