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
12 "github.com/99designs/gqlgen/graphql"
13 "github.com/99designs/gqlgen/graphql/introspection"
14 "github.com/vektah/gqlparser/v2/ast"
15)
16
17// region ************************** generated!.gotpl **************************
18
19// endregion ************************** generated!.gotpl **************************
20
21// region ***************************** args.gotpl *****************************
22
23func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
24 var err error
25 args := map[string]interface{}{}
26 var arg0 bool
27 if tmp, ok := rawArgs["includeDeprecated"]; ok {
28 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
29 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
30 if err != nil {
31 return nil, err
32 }
33 }
34 args["includeDeprecated"] = arg0
35 return args, nil
36}
37
38func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
39 var err error
40 args := map[string]interface{}{}
41 var arg0 bool
42 if tmp, ok := rawArgs["includeDeprecated"]; ok {
43 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
44 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
45 if err != nil {
46 return nil, err
47 }
48 }
49 args["includeDeprecated"] = arg0
50 return args, nil
51}
52
53// endregion ***************************** args.gotpl *****************************
54
55// region ************************** directives.gotpl **************************
56
57// endregion ************************** directives.gotpl **************************
58
59// region **************************** field.gotpl *****************************
60
61func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
62 fc, err := ec.fieldContext___Directive_name(ctx, field)
63 if err != nil {
64 return graphql.Null
65 }
66 ctx = graphql.WithFieldContext(ctx, fc)
67 defer func() {
68 if r := recover(); r != nil {
69 ec.Error(ctx, ec.Recover(ctx, r))
70 ret = graphql.Null
71 }
72 }()
73 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
74 ctx = rctx // use context from middleware stack in children
75 return obj.Name, nil
76 })
77 if err != nil {
78 ec.Error(ctx, err)
79 return graphql.Null
80 }
81 if resTmp == nil {
82 if !graphql.HasFieldError(ctx, fc) {
83 ec.Errorf(ctx, "must not be null")
84 }
85 return graphql.Null
86 }
87 res := resTmp.(string)
88 fc.Result = res
89 return ec.marshalNString2string(ctx, field.Selections, res)
90}
91
92func (ec *executionContext) fieldContext___Directive_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
93 fc = &graphql.FieldContext{
94 Object: "__Directive",
95 Field: field,
96 IsMethod: false,
97 IsResolver: false,
98 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
99 return nil, errors.New("field of type String does not have child fields")
100 },
101 }
102 return fc, nil
103}
104
105func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
106 fc, err := ec.fieldContext___Directive_description(ctx, field)
107 if err != nil {
108 return graphql.Null
109 }
110 ctx = graphql.WithFieldContext(ctx, fc)
111 defer func() {
112 if r := recover(); r != nil {
113 ec.Error(ctx, ec.Recover(ctx, r))
114 ret = graphql.Null
115 }
116 }()
117 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
118 ctx = rctx // use context from middleware stack in children
119 return obj.Description(), nil
120 })
121 if err != nil {
122 ec.Error(ctx, err)
123 return graphql.Null
124 }
125 if resTmp == nil {
126 return graphql.Null
127 }
128 res := resTmp.(*string)
129 fc.Result = res
130 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
131}
132
133func (ec *executionContext) fieldContext___Directive_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
134 fc = &graphql.FieldContext{
135 Object: "__Directive",
136 Field: field,
137 IsMethod: true,
138 IsResolver: false,
139 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
140 return nil, errors.New("field of type String does not have child fields")
141 },
142 }
143 return fc, nil
144}
145
146func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
147 fc, err := ec.fieldContext___Directive_locations(ctx, field)
148 if err != nil {
149 return graphql.Null
150 }
151 ctx = graphql.WithFieldContext(ctx, fc)
152 defer func() {
153 if r := recover(); r != nil {
154 ec.Error(ctx, ec.Recover(ctx, r))
155 ret = graphql.Null
156 }
157 }()
158 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
159 ctx = rctx // use context from middleware stack in children
160 return obj.Locations, nil
161 })
162 if err != nil {
163 ec.Error(ctx, err)
164 return graphql.Null
165 }
166 if resTmp == nil {
167 if !graphql.HasFieldError(ctx, fc) {
168 ec.Errorf(ctx, "must not be null")
169 }
170 return graphql.Null
171 }
172 res := resTmp.([]string)
173 fc.Result = res
174 return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
175}
176
177func (ec *executionContext) fieldContext___Directive_locations(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
178 fc = &graphql.FieldContext{
179 Object: "__Directive",
180 Field: field,
181 IsMethod: false,
182 IsResolver: false,
183 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
184 return nil, errors.New("field of type __DirectiveLocation does not have child fields")
185 },
186 }
187 return fc, nil
188}
189
190func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
191 fc, err := ec.fieldContext___Directive_args(ctx, field)
192 if err != nil {
193 return graphql.Null
194 }
195 ctx = graphql.WithFieldContext(ctx, fc)
196 defer func() {
197 if r := recover(); r != nil {
198 ec.Error(ctx, ec.Recover(ctx, r))
199 ret = graphql.Null
200 }
201 }()
202 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
203 ctx = rctx // use context from middleware stack in children
204 return obj.Args, nil
205 })
206 if err != nil {
207 ec.Error(ctx, err)
208 return graphql.Null
209 }
210 if resTmp == nil {
211 if !graphql.HasFieldError(ctx, fc) {
212 ec.Errorf(ctx, "must not be null")
213 }
214 return graphql.Null
215 }
216 res := resTmp.([]introspection.InputValue)
217 fc.Result = res
218 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
219}
220
221func (ec *executionContext) fieldContext___Directive_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
222 fc = &graphql.FieldContext{
223 Object: "__Directive",
224 Field: field,
225 IsMethod: false,
226 IsResolver: false,
227 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
228 switch field.Name {
229 case "name":
230 return ec.fieldContext___InputValue_name(ctx, field)
231 case "description":
232 return ec.fieldContext___InputValue_description(ctx, field)
233 case "type":
234 return ec.fieldContext___InputValue_type(ctx, field)
235 case "defaultValue":
236 return ec.fieldContext___InputValue_defaultValue(ctx, field)
237 }
238 return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
239 },
240 }
241 return fc, nil
242}
243
244func (ec *executionContext) ___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
245 fc, err := ec.fieldContext___Directive_isRepeatable(ctx, field)
246 if err != nil {
247 return graphql.Null
248 }
249 ctx = graphql.WithFieldContext(ctx, fc)
250 defer func() {
251 if r := recover(); r != nil {
252 ec.Error(ctx, ec.Recover(ctx, r))
253 ret = graphql.Null
254 }
255 }()
256 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
257 ctx = rctx // use context from middleware stack in children
258 return obj.IsRepeatable, nil
259 })
260 if err != nil {
261 ec.Error(ctx, err)
262 return graphql.Null
263 }
264 if resTmp == nil {
265 if !graphql.HasFieldError(ctx, fc) {
266 ec.Errorf(ctx, "must not be null")
267 }
268 return graphql.Null
269 }
270 res := resTmp.(bool)
271 fc.Result = res
272 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
273}
274
275func (ec *executionContext) fieldContext___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
276 fc = &graphql.FieldContext{
277 Object: "__Directive",
278 Field: field,
279 IsMethod: false,
280 IsResolver: false,
281 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
282 return nil, errors.New("field of type Boolean does not have child fields")
283 },
284 }
285 return fc, nil
286}
287
288func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
289 fc, err := ec.fieldContext___EnumValue_name(ctx, field)
290 if err != nil {
291 return graphql.Null
292 }
293 ctx = graphql.WithFieldContext(ctx, fc)
294 defer func() {
295 if r := recover(); r != nil {
296 ec.Error(ctx, ec.Recover(ctx, r))
297 ret = graphql.Null
298 }
299 }()
300 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
301 ctx = rctx // use context from middleware stack in children
302 return obj.Name, nil
303 })
304 if err != nil {
305 ec.Error(ctx, err)
306 return graphql.Null
307 }
308 if resTmp == nil {
309 if !graphql.HasFieldError(ctx, fc) {
310 ec.Errorf(ctx, "must not be null")
311 }
312 return graphql.Null
313 }
314 res := resTmp.(string)
315 fc.Result = res
316 return ec.marshalNString2string(ctx, field.Selections, res)
317}
318
319func (ec *executionContext) fieldContext___EnumValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
320 fc = &graphql.FieldContext{
321 Object: "__EnumValue",
322 Field: field,
323 IsMethod: false,
324 IsResolver: false,
325 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
326 return nil, errors.New("field of type String does not have child fields")
327 },
328 }
329 return fc, nil
330}
331
332func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
333 fc, err := ec.fieldContext___EnumValue_description(ctx, field)
334 if err != nil {
335 return graphql.Null
336 }
337 ctx = graphql.WithFieldContext(ctx, fc)
338 defer func() {
339 if r := recover(); r != nil {
340 ec.Error(ctx, ec.Recover(ctx, r))
341 ret = graphql.Null
342 }
343 }()
344 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
345 ctx = rctx // use context from middleware stack in children
346 return obj.Description(), nil
347 })
348 if err != nil {
349 ec.Error(ctx, err)
350 return graphql.Null
351 }
352 if resTmp == nil {
353 return graphql.Null
354 }
355 res := resTmp.(*string)
356 fc.Result = res
357 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
358}
359
360func (ec *executionContext) fieldContext___EnumValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
361 fc = &graphql.FieldContext{
362 Object: "__EnumValue",
363 Field: field,
364 IsMethod: true,
365 IsResolver: false,
366 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
367 return nil, errors.New("field of type String does not have child fields")
368 },
369 }
370 return fc, nil
371}
372
373func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
374 fc, err := ec.fieldContext___EnumValue_isDeprecated(ctx, field)
375 if err != nil {
376 return graphql.Null
377 }
378 ctx = graphql.WithFieldContext(ctx, fc)
379 defer func() {
380 if r := recover(); r != nil {
381 ec.Error(ctx, ec.Recover(ctx, r))
382 ret = graphql.Null
383 }
384 }()
385 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
386 ctx = rctx // use context from middleware stack in children
387 return obj.IsDeprecated(), nil
388 })
389 if err != nil {
390 ec.Error(ctx, err)
391 return graphql.Null
392 }
393 if resTmp == nil {
394 if !graphql.HasFieldError(ctx, fc) {
395 ec.Errorf(ctx, "must not be null")
396 }
397 return graphql.Null
398 }
399 res := resTmp.(bool)
400 fc.Result = res
401 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
402}
403
404func (ec *executionContext) fieldContext___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
405 fc = &graphql.FieldContext{
406 Object: "__EnumValue",
407 Field: field,
408 IsMethod: true,
409 IsResolver: false,
410 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
411 return nil, errors.New("field of type Boolean does not have child fields")
412 },
413 }
414 return fc, nil
415}
416
417func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
418 fc, err := ec.fieldContext___EnumValue_deprecationReason(ctx, field)
419 if err != nil {
420 return graphql.Null
421 }
422 ctx = graphql.WithFieldContext(ctx, fc)
423 defer func() {
424 if r := recover(); r != nil {
425 ec.Error(ctx, ec.Recover(ctx, r))
426 ret = graphql.Null
427 }
428 }()
429 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
430 ctx = rctx // use context from middleware stack in children
431 return obj.DeprecationReason(), nil
432 })
433 if err != nil {
434 ec.Error(ctx, err)
435 return graphql.Null
436 }
437 if resTmp == nil {
438 return graphql.Null
439 }
440 res := resTmp.(*string)
441 fc.Result = res
442 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
443}
444
445func (ec *executionContext) fieldContext___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
446 fc = &graphql.FieldContext{
447 Object: "__EnumValue",
448 Field: field,
449 IsMethod: true,
450 IsResolver: false,
451 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
452 return nil, errors.New("field of type String does not have child fields")
453 },
454 }
455 return fc, nil
456}
457
458func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
459 fc, err := ec.fieldContext___Field_name(ctx, field)
460 if err != nil {
461 return graphql.Null
462 }
463 ctx = graphql.WithFieldContext(ctx, fc)
464 defer func() {
465 if r := recover(); r != nil {
466 ec.Error(ctx, ec.Recover(ctx, r))
467 ret = graphql.Null
468 }
469 }()
470 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
471 ctx = rctx // use context from middleware stack in children
472 return obj.Name, nil
473 })
474 if err != nil {
475 ec.Error(ctx, err)
476 return graphql.Null
477 }
478 if resTmp == nil {
479 if !graphql.HasFieldError(ctx, fc) {
480 ec.Errorf(ctx, "must not be null")
481 }
482 return graphql.Null
483 }
484 res := resTmp.(string)
485 fc.Result = res
486 return ec.marshalNString2string(ctx, field.Selections, res)
487}
488
489func (ec *executionContext) fieldContext___Field_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
490 fc = &graphql.FieldContext{
491 Object: "__Field",
492 Field: field,
493 IsMethod: false,
494 IsResolver: false,
495 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
496 return nil, errors.New("field of type String does not have child fields")
497 },
498 }
499 return fc, nil
500}
501
502func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
503 fc, err := ec.fieldContext___Field_description(ctx, field)
504 if err != nil {
505 return graphql.Null
506 }
507 ctx = graphql.WithFieldContext(ctx, fc)
508 defer func() {
509 if r := recover(); r != nil {
510 ec.Error(ctx, ec.Recover(ctx, r))
511 ret = graphql.Null
512 }
513 }()
514 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
515 ctx = rctx // use context from middleware stack in children
516 return obj.Description(), nil
517 })
518 if err != nil {
519 ec.Error(ctx, err)
520 return graphql.Null
521 }
522 if resTmp == nil {
523 return graphql.Null
524 }
525 res := resTmp.(*string)
526 fc.Result = res
527 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
528}
529
530func (ec *executionContext) fieldContext___Field_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
531 fc = &graphql.FieldContext{
532 Object: "__Field",
533 Field: field,
534 IsMethod: true,
535 IsResolver: false,
536 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
537 return nil, errors.New("field of type String does not have child fields")
538 },
539 }
540 return fc, nil
541}
542
543func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
544 fc, err := ec.fieldContext___Field_args(ctx, field)
545 if err != nil {
546 return graphql.Null
547 }
548 ctx = graphql.WithFieldContext(ctx, fc)
549 defer func() {
550 if r := recover(); r != nil {
551 ec.Error(ctx, ec.Recover(ctx, r))
552 ret = graphql.Null
553 }
554 }()
555 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
556 ctx = rctx // use context from middleware stack in children
557 return obj.Args, nil
558 })
559 if err != nil {
560 ec.Error(ctx, err)
561 return graphql.Null
562 }
563 if resTmp == nil {
564 if !graphql.HasFieldError(ctx, fc) {
565 ec.Errorf(ctx, "must not be null")
566 }
567 return graphql.Null
568 }
569 res := resTmp.([]introspection.InputValue)
570 fc.Result = res
571 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
572}
573
574func (ec *executionContext) fieldContext___Field_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
575 fc = &graphql.FieldContext{
576 Object: "__Field",
577 Field: field,
578 IsMethod: false,
579 IsResolver: false,
580 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
581 switch field.Name {
582 case "name":
583 return ec.fieldContext___InputValue_name(ctx, field)
584 case "description":
585 return ec.fieldContext___InputValue_description(ctx, field)
586 case "type":
587 return ec.fieldContext___InputValue_type(ctx, field)
588 case "defaultValue":
589 return ec.fieldContext___InputValue_defaultValue(ctx, field)
590 }
591 return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
592 },
593 }
594 return fc, nil
595}
596
597func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
598 fc, err := ec.fieldContext___Field_type(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) (interface{}, error) {
610 ctx = rctx // use context from middleware stack in children
611 return obj.Type, nil
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.(*introspection.Type)
624 fc.Result = res
625 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
626}
627
628func (ec *executionContext) fieldContext___Field_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
629 fc = &graphql.FieldContext{
630 Object: "__Field",
631 Field: field,
632 IsMethod: false,
633 IsResolver: false,
634 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
635 switch field.Name {
636 case "kind":
637 return ec.fieldContext___Type_kind(ctx, field)
638 case "name":
639 return ec.fieldContext___Type_name(ctx, field)
640 case "description":
641 return ec.fieldContext___Type_description(ctx, field)
642 case "fields":
643 return ec.fieldContext___Type_fields(ctx, field)
644 case "interfaces":
645 return ec.fieldContext___Type_interfaces(ctx, field)
646 case "possibleTypes":
647 return ec.fieldContext___Type_possibleTypes(ctx, field)
648 case "enumValues":
649 return ec.fieldContext___Type_enumValues(ctx, field)
650 case "inputFields":
651 return ec.fieldContext___Type_inputFields(ctx, field)
652 case "ofType":
653 return ec.fieldContext___Type_ofType(ctx, field)
654 case "specifiedByURL":
655 return ec.fieldContext___Type_specifiedByURL(ctx, field)
656 }
657 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
658 },
659 }
660 return fc, nil
661}
662
663func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
664 fc, err := ec.fieldContext___Field_isDeprecated(ctx, field)
665 if err != nil {
666 return graphql.Null
667 }
668 ctx = graphql.WithFieldContext(ctx, fc)
669 defer func() {
670 if r := recover(); r != nil {
671 ec.Error(ctx, ec.Recover(ctx, r))
672 ret = graphql.Null
673 }
674 }()
675 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
676 ctx = rctx // use context from middleware stack in children
677 return obj.IsDeprecated(), nil
678 })
679 if err != nil {
680 ec.Error(ctx, err)
681 return graphql.Null
682 }
683 if resTmp == nil {
684 if !graphql.HasFieldError(ctx, fc) {
685 ec.Errorf(ctx, "must not be null")
686 }
687 return graphql.Null
688 }
689 res := resTmp.(bool)
690 fc.Result = res
691 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
692}
693
694func (ec *executionContext) fieldContext___Field_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
695 fc = &graphql.FieldContext{
696 Object: "__Field",
697 Field: field,
698 IsMethod: true,
699 IsResolver: false,
700 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
701 return nil, errors.New("field of type Boolean does not have child fields")
702 },
703 }
704 return fc, nil
705}
706
707func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
708 fc, err := ec.fieldContext___Field_deprecationReason(ctx, field)
709 if err != nil {
710 return graphql.Null
711 }
712 ctx = graphql.WithFieldContext(ctx, fc)
713 defer func() {
714 if r := recover(); r != nil {
715 ec.Error(ctx, ec.Recover(ctx, r))
716 ret = graphql.Null
717 }
718 }()
719 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
720 ctx = rctx // use context from middleware stack in children
721 return obj.DeprecationReason(), nil
722 })
723 if err != nil {
724 ec.Error(ctx, err)
725 return graphql.Null
726 }
727 if resTmp == nil {
728 return graphql.Null
729 }
730 res := resTmp.(*string)
731 fc.Result = res
732 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
733}
734
735func (ec *executionContext) fieldContext___Field_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
736 fc = &graphql.FieldContext{
737 Object: "__Field",
738 Field: field,
739 IsMethod: true,
740 IsResolver: false,
741 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
742 return nil, errors.New("field of type String does not have child fields")
743 },
744 }
745 return fc, nil
746}
747
748func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
749 fc, err := ec.fieldContext___InputValue_name(ctx, field)
750 if err != nil {
751 return graphql.Null
752 }
753 ctx = graphql.WithFieldContext(ctx, fc)
754 defer func() {
755 if r := recover(); r != nil {
756 ec.Error(ctx, ec.Recover(ctx, r))
757 ret = graphql.Null
758 }
759 }()
760 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
761 ctx = rctx // use context from middleware stack in children
762 return obj.Name, nil
763 })
764 if err != nil {
765 ec.Error(ctx, err)
766 return graphql.Null
767 }
768 if resTmp == nil {
769 if !graphql.HasFieldError(ctx, fc) {
770 ec.Errorf(ctx, "must not be null")
771 }
772 return graphql.Null
773 }
774 res := resTmp.(string)
775 fc.Result = res
776 return ec.marshalNString2string(ctx, field.Selections, res)
777}
778
779func (ec *executionContext) fieldContext___InputValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
780 fc = &graphql.FieldContext{
781 Object: "__InputValue",
782 Field: field,
783 IsMethod: false,
784 IsResolver: false,
785 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
786 return nil, errors.New("field of type String does not have child fields")
787 },
788 }
789 return fc, nil
790}
791
792func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
793 fc, err := ec.fieldContext___InputValue_description(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) (interface{}, error) {
805 ctx = rctx // use context from middleware stack in children
806 return obj.Description(), nil
807 })
808 if err != nil {
809 ec.Error(ctx, err)
810 return graphql.Null
811 }
812 if resTmp == nil {
813 return graphql.Null
814 }
815 res := resTmp.(*string)
816 fc.Result = res
817 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
818}
819
820func (ec *executionContext) fieldContext___InputValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
821 fc = &graphql.FieldContext{
822 Object: "__InputValue",
823 Field: field,
824 IsMethod: true,
825 IsResolver: false,
826 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
827 return nil, errors.New("field of type String does not have child fields")
828 },
829 }
830 return fc, nil
831}
832
833func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
834 fc, err := ec.fieldContext___InputValue_type(ctx, field)
835 if err != nil {
836 return graphql.Null
837 }
838 ctx = graphql.WithFieldContext(ctx, fc)
839 defer func() {
840 if r := recover(); r != nil {
841 ec.Error(ctx, ec.Recover(ctx, r))
842 ret = graphql.Null
843 }
844 }()
845 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
846 ctx = rctx // use context from middleware stack in children
847 return obj.Type, nil
848 })
849 if err != nil {
850 ec.Error(ctx, err)
851 return graphql.Null
852 }
853 if resTmp == nil {
854 if !graphql.HasFieldError(ctx, fc) {
855 ec.Errorf(ctx, "must not be null")
856 }
857 return graphql.Null
858 }
859 res := resTmp.(*introspection.Type)
860 fc.Result = res
861 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
862}
863
864func (ec *executionContext) fieldContext___InputValue_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
865 fc = &graphql.FieldContext{
866 Object: "__InputValue",
867 Field: field,
868 IsMethod: false,
869 IsResolver: false,
870 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
871 switch field.Name {
872 case "kind":
873 return ec.fieldContext___Type_kind(ctx, field)
874 case "name":
875 return ec.fieldContext___Type_name(ctx, field)
876 case "description":
877 return ec.fieldContext___Type_description(ctx, field)
878 case "fields":
879 return ec.fieldContext___Type_fields(ctx, field)
880 case "interfaces":
881 return ec.fieldContext___Type_interfaces(ctx, field)
882 case "possibleTypes":
883 return ec.fieldContext___Type_possibleTypes(ctx, field)
884 case "enumValues":
885 return ec.fieldContext___Type_enumValues(ctx, field)
886 case "inputFields":
887 return ec.fieldContext___Type_inputFields(ctx, field)
888 case "ofType":
889 return ec.fieldContext___Type_ofType(ctx, field)
890 case "specifiedByURL":
891 return ec.fieldContext___Type_specifiedByURL(ctx, field)
892 }
893 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
894 },
895 }
896 return fc, nil
897}
898
899func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
900 fc, err := ec.fieldContext___InputValue_defaultValue(ctx, field)
901 if err != nil {
902 return graphql.Null
903 }
904 ctx = graphql.WithFieldContext(ctx, fc)
905 defer func() {
906 if r := recover(); r != nil {
907 ec.Error(ctx, ec.Recover(ctx, r))
908 ret = graphql.Null
909 }
910 }()
911 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
912 ctx = rctx // use context from middleware stack in children
913 return obj.DefaultValue, nil
914 })
915 if err != nil {
916 ec.Error(ctx, err)
917 return graphql.Null
918 }
919 if resTmp == nil {
920 return graphql.Null
921 }
922 res := resTmp.(*string)
923 fc.Result = res
924 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
925}
926
927func (ec *executionContext) fieldContext___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
928 fc = &graphql.FieldContext{
929 Object: "__InputValue",
930 Field: field,
931 IsMethod: false,
932 IsResolver: false,
933 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
934 return nil, errors.New("field of type String does not have child fields")
935 },
936 }
937 return fc, nil
938}
939
940func (ec *executionContext) ___Schema_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
941 fc, err := ec.fieldContext___Schema_description(ctx, field)
942 if err != nil {
943 return graphql.Null
944 }
945 ctx = graphql.WithFieldContext(ctx, fc)
946 defer func() {
947 if r := recover(); r != nil {
948 ec.Error(ctx, ec.Recover(ctx, r))
949 ret = graphql.Null
950 }
951 }()
952 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
953 ctx = rctx // use context from middleware stack in children
954 return obj.Description(), nil
955 })
956 if err != nil {
957 ec.Error(ctx, err)
958 return graphql.Null
959 }
960 if resTmp == nil {
961 return graphql.Null
962 }
963 res := resTmp.(*string)
964 fc.Result = res
965 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
966}
967
968func (ec *executionContext) fieldContext___Schema_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
969 fc = &graphql.FieldContext{
970 Object: "__Schema",
971 Field: field,
972 IsMethod: true,
973 IsResolver: false,
974 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
975 return nil, errors.New("field of type String does not have child fields")
976 },
977 }
978 return fc, nil
979}
980
981func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
982 fc, err := ec.fieldContext___Schema_types(ctx, field)
983 if err != nil {
984 return graphql.Null
985 }
986 ctx = graphql.WithFieldContext(ctx, fc)
987 defer func() {
988 if r := recover(); r != nil {
989 ec.Error(ctx, ec.Recover(ctx, r))
990 ret = graphql.Null
991 }
992 }()
993 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
994 ctx = rctx // use context from middleware stack in children
995 return obj.Types(), nil
996 })
997 if err != nil {
998 ec.Error(ctx, err)
999 return graphql.Null
1000 }
1001 if resTmp == nil {
1002 if !graphql.HasFieldError(ctx, fc) {
1003 ec.Errorf(ctx, "must not be null")
1004 }
1005 return graphql.Null
1006 }
1007 res := resTmp.([]introspection.Type)
1008 fc.Result = res
1009 return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
1010}
1011
1012func (ec *executionContext) fieldContext___Schema_types(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1013 fc = &graphql.FieldContext{
1014 Object: "__Schema",
1015 Field: field,
1016 IsMethod: true,
1017 IsResolver: false,
1018 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1019 switch field.Name {
1020 case "kind":
1021 return ec.fieldContext___Type_kind(ctx, field)
1022 case "name":
1023 return ec.fieldContext___Type_name(ctx, field)
1024 case "description":
1025 return ec.fieldContext___Type_description(ctx, field)
1026 case "fields":
1027 return ec.fieldContext___Type_fields(ctx, field)
1028 case "interfaces":
1029 return ec.fieldContext___Type_interfaces(ctx, field)
1030 case "possibleTypes":
1031 return ec.fieldContext___Type_possibleTypes(ctx, field)
1032 case "enumValues":
1033 return ec.fieldContext___Type_enumValues(ctx, field)
1034 case "inputFields":
1035 return ec.fieldContext___Type_inputFields(ctx, field)
1036 case "ofType":
1037 return ec.fieldContext___Type_ofType(ctx, field)
1038 case "specifiedByURL":
1039 return ec.fieldContext___Type_specifiedByURL(ctx, field)
1040 }
1041 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1042 },
1043 }
1044 return fc, nil
1045}
1046
1047func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1048 fc, err := ec.fieldContext___Schema_queryType(ctx, field)
1049 if err != nil {
1050 return graphql.Null
1051 }
1052 ctx = graphql.WithFieldContext(ctx, fc)
1053 defer func() {
1054 if r := recover(); r != nil {
1055 ec.Error(ctx, ec.Recover(ctx, r))
1056 ret = graphql.Null
1057 }
1058 }()
1059 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1060 ctx = rctx // use context from middleware stack in children
1061 return obj.QueryType(), nil
1062 })
1063 if err != nil {
1064 ec.Error(ctx, err)
1065 return graphql.Null
1066 }
1067 if resTmp == nil {
1068 if !graphql.HasFieldError(ctx, fc) {
1069 ec.Errorf(ctx, "must not be null")
1070 }
1071 return graphql.Null
1072 }
1073 res := resTmp.(*introspection.Type)
1074 fc.Result = res
1075 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1076}
1077
1078func (ec *executionContext) fieldContext___Schema_queryType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1079 fc = &graphql.FieldContext{
1080 Object: "__Schema",
1081 Field: field,
1082 IsMethod: true,
1083 IsResolver: false,
1084 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1085 switch field.Name {
1086 case "kind":
1087 return ec.fieldContext___Type_kind(ctx, field)
1088 case "name":
1089 return ec.fieldContext___Type_name(ctx, field)
1090 case "description":
1091 return ec.fieldContext___Type_description(ctx, field)
1092 case "fields":
1093 return ec.fieldContext___Type_fields(ctx, field)
1094 case "interfaces":
1095 return ec.fieldContext___Type_interfaces(ctx, field)
1096 case "possibleTypes":
1097 return ec.fieldContext___Type_possibleTypes(ctx, field)
1098 case "enumValues":
1099 return ec.fieldContext___Type_enumValues(ctx, field)
1100 case "inputFields":
1101 return ec.fieldContext___Type_inputFields(ctx, field)
1102 case "ofType":
1103 return ec.fieldContext___Type_ofType(ctx, field)
1104 case "specifiedByURL":
1105 return ec.fieldContext___Type_specifiedByURL(ctx, field)
1106 }
1107 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1108 },
1109 }
1110 return fc, nil
1111}
1112
1113func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1114 fc, err := ec.fieldContext___Schema_mutationType(ctx, field)
1115 if err != nil {
1116 return graphql.Null
1117 }
1118 ctx = graphql.WithFieldContext(ctx, fc)
1119 defer func() {
1120 if r := recover(); r != nil {
1121 ec.Error(ctx, ec.Recover(ctx, r))
1122 ret = graphql.Null
1123 }
1124 }()
1125 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1126 ctx = rctx // use context from middleware stack in children
1127 return obj.MutationType(), nil
1128 })
1129 if err != nil {
1130 ec.Error(ctx, err)
1131 return graphql.Null
1132 }
1133 if resTmp == nil {
1134 return graphql.Null
1135 }
1136 res := resTmp.(*introspection.Type)
1137 fc.Result = res
1138 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1139}
1140
1141func (ec *executionContext) fieldContext___Schema_mutationType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1142 fc = &graphql.FieldContext{
1143 Object: "__Schema",
1144 Field: field,
1145 IsMethod: true,
1146 IsResolver: false,
1147 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1148 switch field.Name {
1149 case "kind":
1150 return ec.fieldContext___Type_kind(ctx, field)
1151 case "name":
1152 return ec.fieldContext___Type_name(ctx, field)
1153 case "description":
1154 return ec.fieldContext___Type_description(ctx, field)
1155 case "fields":
1156 return ec.fieldContext___Type_fields(ctx, field)
1157 case "interfaces":
1158 return ec.fieldContext___Type_interfaces(ctx, field)
1159 case "possibleTypes":
1160 return ec.fieldContext___Type_possibleTypes(ctx, field)
1161 case "enumValues":
1162 return ec.fieldContext___Type_enumValues(ctx, field)
1163 case "inputFields":
1164 return ec.fieldContext___Type_inputFields(ctx, field)
1165 case "ofType":
1166 return ec.fieldContext___Type_ofType(ctx, field)
1167 case "specifiedByURL":
1168 return ec.fieldContext___Type_specifiedByURL(ctx, field)
1169 }
1170 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1171 },
1172 }
1173 return fc, nil
1174}
1175
1176func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1177 fc, err := ec.fieldContext___Schema_subscriptionType(ctx, field)
1178 if err != nil {
1179 return graphql.Null
1180 }
1181 ctx = graphql.WithFieldContext(ctx, fc)
1182 defer func() {
1183 if r := recover(); r != nil {
1184 ec.Error(ctx, ec.Recover(ctx, r))
1185 ret = graphql.Null
1186 }
1187 }()
1188 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1189 ctx = rctx // use context from middleware stack in children
1190 return obj.SubscriptionType(), nil
1191 })
1192 if err != nil {
1193 ec.Error(ctx, err)
1194 return graphql.Null
1195 }
1196 if resTmp == nil {
1197 return graphql.Null
1198 }
1199 res := resTmp.(*introspection.Type)
1200 fc.Result = res
1201 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1202}
1203
1204func (ec *executionContext) fieldContext___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1205 fc = &graphql.FieldContext{
1206 Object: "__Schema",
1207 Field: field,
1208 IsMethod: true,
1209 IsResolver: false,
1210 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1211 switch field.Name {
1212 case "kind":
1213 return ec.fieldContext___Type_kind(ctx, field)
1214 case "name":
1215 return ec.fieldContext___Type_name(ctx, field)
1216 case "description":
1217 return ec.fieldContext___Type_description(ctx, field)
1218 case "fields":
1219 return ec.fieldContext___Type_fields(ctx, field)
1220 case "interfaces":
1221 return ec.fieldContext___Type_interfaces(ctx, field)
1222 case "possibleTypes":
1223 return ec.fieldContext___Type_possibleTypes(ctx, field)
1224 case "enumValues":
1225 return ec.fieldContext___Type_enumValues(ctx, field)
1226 case "inputFields":
1227 return ec.fieldContext___Type_inputFields(ctx, field)
1228 case "ofType":
1229 return ec.fieldContext___Type_ofType(ctx, field)
1230 case "specifiedByURL":
1231 return ec.fieldContext___Type_specifiedByURL(ctx, field)
1232 }
1233 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1234 },
1235 }
1236 return fc, nil
1237}
1238
1239func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1240 fc, err := ec.fieldContext___Schema_directives(ctx, field)
1241 if err != nil {
1242 return graphql.Null
1243 }
1244 ctx = graphql.WithFieldContext(ctx, fc)
1245 defer func() {
1246 if r := recover(); r != nil {
1247 ec.Error(ctx, ec.Recover(ctx, r))
1248 ret = graphql.Null
1249 }
1250 }()
1251 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1252 ctx = rctx // use context from middleware stack in children
1253 return obj.Directives(), nil
1254 })
1255 if err != nil {
1256 ec.Error(ctx, err)
1257 return graphql.Null
1258 }
1259 if resTmp == nil {
1260 if !graphql.HasFieldError(ctx, fc) {
1261 ec.Errorf(ctx, "must not be null")
1262 }
1263 return graphql.Null
1264 }
1265 res := resTmp.([]introspection.Directive)
1266 fc.Result = res
1267 return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
1268}
1269
1270func (ec *executionContext) fieldContext___Schema_directives(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1271 fc = &graphql.FieldContext{
1272 Object: "__Schema",
1273 Field: field,
1274 IsMethod: true,
1275 IsResolver: false,
1276 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1277 switch field.Name {
1278 case "name":
1279 return ec.fieldContext___Directive_name(ctx, field)
1280 case "description":
1281 return ec.fieldContext___Directive_description(ctx, field)
1282 case "locations":
1283 return ec.fieldContext___Directive_locations(ctx, field)
1284 case "args":
1285 return ec.fieldContext___Directive_args(ctx, field)
1286 case "isRepeatable":
1287 return ec.fieldContext___Directive_isRepeatable(ctx, field)
1288 }
1289 return nil, fmt.Errorf("no field named %q was found under type __Directive", field.Name)
1290 },
1291 }
1292 return fc, nil
1293}
1294
1295func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1296 fc, err := ec.fieldContext___Type_kind(ctx, field)
1297 if err != nil {
1298 return graphql.Null
1299 }
1300 ctx = graphql.WithFieldContext(ctx, fc)
1301 defer func() {
1302 if r := recover(); r != nil {
1303 ec.Error(ctx, ec.Recover(ctx, r))
1304 ret = graphql.Null
1305 }
1306 }()
1307 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1308 ctx = rctx // use context from middleware stack in children
1309 return obj.Kind(), nil
1310 })
1311 if err != nil {
1312 ec.Error(ctx, err)
1313 return graphql.Null
1314 }
1315 if resTmp == nil {
1316 if !graphql.HasFieldError(ctx, fc) {
1317 ec.Errorf(ctx, "must not be null")
1318 }
1319 return graphql.Null
1320 }
1321 res := resTmp.(string)
1322 fc.Result = res
1323 return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
1324}
1325
1326func (ec *executionContext) fieldContext___Type_kind(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1327 fc = &graphql.FieldContext{
1328 Object: "__Type",
1329 Field: field,
1330 IsMethod: true,
1331 IsResolver: false,
1332 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1333 return nil, errors.New("field of type __TypeKind does not have child fields")
1334 },
1335 }
1336 return fc, nil
1337}
1338
1339func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1340 fc, err := ec.fieldContext___Type_name(ctx, field)
1341 if err != nil {
1342 return graphql.Null
1343 }
1344 ctx = graphql.WithFieldContext(ctx, fc)
1345 defer func() {
1346 if r := recover(); r != nil {
1347 ec.Error(ctx, ec.Recover(ctx, r))
1348 ret = graphql.Null
1349 }
1350 }()
1351 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1352 ctx = rctx // use context from middleware stack in children
1353 return obj.Name(), nil
1354 })
1355 if err != nil {
1356 ec.Error(ctx, err)
1357 return graphql.Null
1358 }
1359 if resTmp == nil {
1360 return graphql.Null
1361 }
1362 res := resTmp.(*string)
1363 fc.Result = res
1364 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
1365}
1366
1367func (ec *executionContext) fieldContext___Type_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1368 fc = &graphql.FieldContext{
1369 Object: "__Type",
1370 Field: field,
1371 IsMethod: true,
1372 IsResolver: false,
1373 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1374 return nil, errors.New("field of type String does not have child fields")
1375 },
1376 }
1377 return fc, nil
1378}
1379
1380func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1381 fc, err := ec.fieldContext___Type_description(ctx, field)
1382 if err != nil {
1383 return graphql.Null
1384 }
1385 ctx = graphql.WithFieldContext(ctx, fc)
1386 defer func() {
1387 if r := recover(); r != nil {
1388 ec.Error(ctx, ec.Recover(ctx, r))
1389 ret = graphql.Null
1390 }
1391 }()
1392 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1393 ctx = rctx // use context from middleware stack in children
1394 return obj.Description(), nil
1395 })
1396 if err != nil {
1397 ec.Error(ctx, err)
1398 return graphql.Null
1399 }
1400 if resTmp == nil {
1401 return graphql.Null
1402 }
1403 res := resTmp.(*string)
1404 fc.Result = res
1405 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
1406}
1407
1408func (ec *executionContext) fieldContext___Type_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1409 fc = &graphql.FieldContext{
1410 Object: "__Type",
1411 Field: field,
1412 IsMethod: true,
1413 IsResolver: false,
1414 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1415 return nil, errors.New("field of type String does not have child fields")
1416 },
1417 }
1418 return fc, nil
1419}
1420
1421func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1422 fc, err := ec.fieldContext___Type_fields(ctx, field)
1423 if err != nil {
1424 return graphql.Null
1425 }
1426 ctx = graphql.WithFieldContext(ctx, fc)
1427 defer func() {
1428 if r := recover(); r != nil {
1429 ec.Error(ctx, ec.Recover(ctx, r))
1430 ret = graphql.Null
1431 }
1432 }()
1433 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1434 ctx = rctx // use context from middleware stack in children
1435 return obj.Fields(fc.Args["includeDeprecated"].(bool)), nil
1436 })
1437 if err != nil {
1438 ec.Error(ctx, err)
1439 return graphql.Null
1440 }
1441 if resTmp == nil {
1442 return graphql.Null
1443 }
1444 res := resTmp.([]introspection.Field)
1445 fc.Result = res
1446 return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
1447}
1448
1449func (ec *executionContext) fieldContext___Type_fields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1450 fc = &graphql.FieldContext{
1451 Object: "__Type",
1452 Field: field,
1453 IsMethod: true,
1454 IsResolver: false,
1455 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1456 switch field.Name {
1457 case "name":
1458 return ec.fieldContext___Field_name(ctx, field)
1459 case "description":
1460 return ec.fieldContext___Field_description(ctx, field)
1461 case "args":
1462 return ec.fieldContext___Field_args(ctx, field)
1463 case "type":
1464 return ec.fieldContext___Field_type(ctx, field)
1465 case "isDeprecated":
1466 return ec.fieldContext___Field_isDeprecated(ctx, field)
1467 case "deprecationReason":
1468 return ec.fieldContext___Field_deprecationReason(ctx, field)
1469 }
1470 return nil, fmt.Errorf("no field named %q was found under type __Field", field.Name)
1471 },
1472 }
1473 defer func() {
1474 if r := recover(); r != nil {
1475 err = ec.Recover(ctx, r)
1476 ec.Error(ctx, err)
1477 }
1478 }()
1479 ctx = graphql.WithFieldContext(ctx, fc)
1480 if fc.Args, err = ec.field___Type_fields_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1481 ec.Error(ctx, err)
1482 return
1483 }
1484 return fc, nil
1485}
1486
1487func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1488 fc, err := ec.fieldContext___Type_interfaces(ctx, field)
1489 if err != nil {
1490 return graphql.Null
1491 }
1492 ctx = graphql.WithFieldContext(ctx, fc)
1493 defer func() {
1494 if r := recover(); r != nil {
1495 ec.Error(ctx, ec.Recover(ctx, r))
1496 ret = graphql.Null
1497 }
1498 }()
1499 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1500 ctx = rctx // use context from middleware stack in children
1501 return obj.Interfaces(), nil
1502 })
1503 if err != nil {
1504 ec.Error(ctx, err)
1505 return graphql.Null
1506 }
1507 if resTmp == nil {
1508 return graphql.Null
1509 }
1510 res := resTmp.([]introspection.Type)
1511 fc.Result = res
1512 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
1513}
1514
1515func (ec *executionContext) fieldContext___Type_interfaces(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1516 fc = &graphql.FieldContext{
1517 Object: "__Type",
1518 Field: field,
1519 IsMethod: true,
1520 IsResolver: false,
1521 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1522 switch field.Name {
1523 case "kind":
1524 return ec.fieldContext___Type_kind(ctx, field)
1525 case "name":
1526 return ec.fieldContext___Type_name(ctx, field)
1527 case "description":
1528 return ec.fieldContext___Type_description(ctx, field)
1529 case "fields":
1530 return ec.fieldContext___Type_fields(ctx, field)
1531 case "interfaces":
1532 return ec.fieldContext___Type_interfaces(ctx, field)
1533 case "possibleTypes":
1534 return ec.fieldContext___Type_possibleTypes(ctx, field)
1535 case "enumValues":
1536 return ec.fieldContext___Type_enumValues(ctx, field)
1537 case "inputFields":
1538 return ec.fieldContext___Type_inputFields(ctx, field)
1539 case "ofType":
1540 return ec.fieldContext___Type_ofType(ctx, field)
1541 case "specifiedByURL":
1542 return ec.fieldContext___Type_specifiedByURL(ctx, field)
1543 }
1544 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1545 },
1546 }
1547 return fc, nil
1548}
1549
1550func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1551 fc, err := ec.fieldContext___Type_possibleTypes(ctx, field)
1552 if err != nil {
1553 return graphql.Null
1554 }
1555 ctx = graphql.WithFieldContext(ctx, fc)
1556 defer func() {
1557 if r := recover(); r != nil {
1558 ec.Error(ctx, ec.Recover(ctx, r))
1559 ret = graphql.Null
1560 }
1561 }()
1562 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1563 ctx = rctx // use context from middleware stack in children
1564 return obj.PossibleTypes(), nil
1565 })
1566 if err != nil {
1567 ec.Error(ctx, err)
1568 return graphql.Null
1569 }
1570 if resTmp == nil {
1571 return graphql.Null
1572 }
1573 res := resTmp.([]introspection.Type)
1574 fc.Result = res
1575 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
1576}
1577
1578func (ec *executionContext) fieldContext___Type_possibleTypes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1579 fc = &graphql.FieldContext{
1580 Object: "__Type",
1581 Field: field,
1582 IsMethod: true,
1583 IsResolver: false,
1584 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1585 switch field.Name {
1586 case "kind":
1587 return ec.fieldContext___Type_kind(ctx, field)
1588 case "name":
1589 return ec.fieldContext___Type_name(ctx, field)
1590 case "description":
1591 return ec.fieldContext___Type_description(ctx, field)
1592 case "fields":
1593 return ec.fieldContext___Type_fields(ctx, field)
1594 case "interfaces":
1595 return ec.fieldContext___Type_interfaces(ctx, field)
1596 case "possibleTypes":
1597 return ec.fieldContext___Type_possibleTypes(ctx, field)
1598 case "enumValues":
1599 return ec.fieldContext___Type_enumValues(ctx, field)
1600 case "inputFields":
1601 return ec.fieldContext___Type_inputFields(ctx, field)
1602 case "ofType":
1603 return ec.fieldContext___Type_ofType(ctx, field)
1604 case "specifiedByURL":
1605 return ec.fieldContext___Type_specifiedByURL(ctx, field)
1606 }
1607 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1608 },
1609 }
1610 return fc, nil
1611}
1612
1613func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1614 fc, err := ec.fieldContext___Type_enumValues(ctx, field)
1615 if err != nil {
1616 return graphql.Null
1617 }
1618 ctx = graphql.WithFieldContext(ctx, fc)
1619 defer func() {
1620 if r := recover(); r != nil {
1621 ec.Error(ctx, ec.Recover(ctx, r))
1622 ret = graphql.Null
1623 }
1624 }()
1625 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1626 ctx = rctx // use context from middleware stack in children
1627 return obj.EnumValues(fc.Args["includeDeprecated"].(bool)), nil
1628 })
1629 if err != nil {
1630 ec.Error(ctx, err)
1631 return graphql.Null
1632 }
1633 if resTmp == nil {
1634 return graphql.Null
1635 }
1636 res := resTmp.([]introspection.EnumValue)
1637 fc.Result = res
1638 return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
1639}
1640
1641func (ec *executionContext) fieldContext___Type_enumValues(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1642 fc = &graphql.FieldContext{
1643 Object: "__Type",
1644 Field: field,
1645 IsMethod: true,
1646 IsResolver: false,
1647 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1648 switch field.Name {
1649 case "name":
1650 return ec.fieldContext___EnumValue_name(ctx, field)
1651 case "description":
1652 return ec.fieldContext___EnumValue_description(ctx, field)
1653 case "isDeprecated":
1654 return ec.fieldContext___EnumValue_isDeprecated(ctx, field)
1655 case "deprecationReason":
1656 return ec.fieldContext___EnumValue_deprecationReason(ctx, field)
1657 }
1658 return nil, fmt.Errorf("no field named %q was found under type __EnumValue", field.Name)
1659 },
1660 }
1661 defer func() {
1662 if r := recover(); r != nil {
1663 err = ec.Recover(ctx, r)
1664 ec.Error(ctx, err)
1665 }
1666 }()
1667 ctx = graphql.WithFieldContext(ctx, fc)
1668 if fc.Args, err = ec.field___Type_enumValues_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1669 ec.Error(ctx, err)
1670 return
1671 }
1672 return fc, nil
1673}
1674
1675func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1676 fc, err := ec.fieldContext___Type_inputFields(ctx, field)
1677 if err != nil {
1678 return graphql.Null
1679 }
1680 ctx = graphql.WithFieldContext(ctx, fc)
1681 defer func() {
1682 if r := recover(); r != nil {
1683 ec.Error(ctx, ec.Recover(ctx, r))
1684 ret = graphql.Null
1685 }
1686 }()
1687 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1688 ctx = rctx // use context from middleware stack in children
1689 return obj.InputFields(), nil
1690 })
1691 if err != nil {
1692 ec.Error(ctx, err)
1693 return graphql.Null
1694 }
1695 if resTmp == nil {
1696 return graphql.Null
1697 }
1698 res := resTmp.([]introspection.InputValue)
1699 fc.Result = res
1700 return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
1701}
1702
1703func (ec *executionContext) fieldContext___Type_inputFields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1704 fc = &graphql.FieldContext{
1705 Object: "__Type",
1706 Field: field,
1707 IsMethod: true,
1708 IsResolver: false,
1709 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1710 switch field.Name {
1711 case "name":
1712 return ec.fieldContext___InputValue_name(ctx, field)
1713 case "description":
1714 return ec.fieldContext___InputValue_description(ctx, field)
1715 case "type":
1716 return ec.fieldContext___InputValue_type(ctx, field)
1717 case "defaultValue":
1718 return ec.fieldContext___InputValue_defaultValue(ctx, field)
1719 }
1720 return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
1721 },
1722 }
1723 return fc, nil
1724}
1725
1726func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1727 fc, err := ec.fieldContext___Type_ofType(ctx, field)
1728 if err != nil {
1729 return graphql.Null
1730 }
1731 ctx = graphql.WithFieldContext(ctx, fc)
1732 defer func() {
1733 if r := recover(); r != nil {
1734 ec.Error(ctx, ec.Recover(ctx, r))
1735 ret = graphql.Null
1736 }
1737 }()
1738 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1739 ctx = rctx // use context from middleware stack in children
1740 return obj.OfType(), nil
1741 })
1742 if err != nil {
1743 ec.Error(ctx, err)
1744 return graphql.Null
1745 }
1746 if resTmp == nil {
1747 return graphql.Null
1748 }
1749 res := resTmp.(*introspection.Type)
1750 fc.Result = res
1751 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1752}
1753
1754func (ec *executionContext) fieldContext___Type_ofType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1755 fc = &graphql.FieldContext{
1756 Object: "__Type",
1757 Field: field,
1758 IsMethod: true,
1759 IsResolver: false,
1760 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1761 switch field.Name {
1762 case "kind":
1763 return ec.fieldContext___Type_kind(ctx, field)
1764 case "name":
1765 return ec.fieldContext___Type_name(ctx, field)
1766 case "description":
1767 return ec.fieldContext___Type_description(ctx, field)
1768 case "fields":
1769 return ec.fieldContext___Type_fields(ctx, field)
1770 case "interfaces":
1771 return ec.fieldContext___Type_interfaces(ctx, field)
1772 case "possibleTypes":
1773 return ec.fieldContext___Type_possibleTypes(ctx, field)
1774 case "enumValues":
1775 return ec.fieldContext___Type_enumValues(ctx, field)
1776 case "inputFields":
1777 return ec.fieldContext___Type_inputFields(ctx, field)
1778 case "ofType":
1779 return ec.fieldContext___Type_ofType(ctx, field)
1780 case "specifiedByURL":
1781 return ec.fieldContext___Type_specifiedByURL(ctx, field)
1782 }
1783 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1784 },
1785 }
1786 return fc, nil
1787}
1788
1789func (ec *executionContext) ___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1790 fc, err := ec.fieldContext___Type_specifiedByURL(ctx, field)
1791 if err != nil {
1792 return graphql.Null
1793 }
1794 ctx = graphql.WithFieldContext(ctx, fc)
1795 defer func() {
1796 if r := recover(); r != nil {
1797 ec.Error(ctx, ec.Recover(ctx, r))
1798 ret = graphql.Null
1799 }
1800 }()
1801 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1802 ctx = rctx // use context from middleware stack in children
1803 return obj.SpecifiedByURL(), nil
1804 })
1805 if err != nil {
1806 ec.Error(ctx, err)
1807 return graphql.Null
1808 }
1809 if resTmp == nil {
1810 return graphql.Null
1811 }
1812 res := resTmp.(*string)
1813 fc.Result = res
1814 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
1815}
1816
1817func (ec *executionContext) fieldContext___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1818 fc = &graphql.FieldContext{
1819 Object: "__Type",
1820 Field: field,
1821 IsMethod: true,
1822 IsResolver: false,
1823 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1824 return nil, errors.New("field of type String does not have child fields")
1825 },
1826 }
1827 return fc, nil
1828}
1829
1830// endregion **************************** field.gotpl *****************************
1831
1832// region **************************** input.gotpl *****************************
1833
1834// endregion **************************** input.gotpl *****************************
1835
1836// region ************************** interface.gotpl ***************************
1837
1838// endregion ************************** interface.gotpl ***************************
1839
1840// region **************************** object.gotpl ****************************
1841
1842var __DirectiveImplementors = []string{"__Directive"}
1843
1844func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
1845 fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
1846 out := graphql.NewFieldSet(fields)
1847 var invalids uint32
1848 for i, field := range fields {
1849 switch field.Name {
1850 case "__typename":
1851 out.Values[i] = graphql.MarshalString("__Directive")
1852 case "name":
1853
1854 out.Values[i] = ec.___Directive_name(ctx, field, obj)
1855
1856 if out.Values[i] == graphql.Null {
1857 invalids++
1858 }
1859 case "description":
1860
1861 out.Values[i] = ec.___Directive_description(ctx, field, obj)
1862
1863 case "locations":
1864
1865 out.Values[i] = ec.___Directive_locations(ctx, field, obj)
1866
1867 if out.Values[i] == graphql.Null {
1868 invalids++
1869 }
1870 case "args":
1871
1872 out.Values[i] = ec.___Directive_args(ctx, field, obj)
1873
1874 if out.Values[i] == graphql.Null {
1875 invalids++
1876 }
1877 case "isRepeatable":
1878
1879 out.Values[i] = ec.___Directive_isRepeatable(ctx, field, obj)
1880
1881 if out.Values[i] == graphql.Null {
1882 invalids++
1883 }
1884 default:
1885 panic("unknown field " + strconv.Quote(field.Name))
1886 }
1887 }
1888 out.Dispatch()
1889 if invalids > 0 {
1890 return graphql.Null
1891 }
1892 return out
1893}
1894
1895var __EnumValueImplementors = []string{"__EnumValue"}
1896
1897func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
1898 fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
1899 out := graphql.NewFieldSet(fields)
1900 var invalids uint32
1901 for i, field := range fields {
1902 switch field.Name {
1903 case "__typename":
1904 out.Values[i] = graphql.MarshalString("__EnumValue")
1905 case "name":
1906
1907 out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
1908
1909 if out.Values[i] == graphql.Null {
1910 invalids++
1911 }
1912 case "description":
1913
1914 out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
1915
1916 case "isDeprecated":
1917
1918 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
1919
1920 if out.Values[i] == graphql.Null {
1921 invalids++
1922 }
1923 case "deprecationReason":
1924
1925 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
1926
1927 default:
1928 panic("unknown field " + strconv.Quote(field.Name))
1929 }
1930 }
1931 out.Dispatch()
1932 if invalids > 0 {
1933 return graphql.Null
1934 }
1935 return out
1936}
1937
1938var __FieldImplementors = []string{"__Field"}
1939
1940func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
1941 fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
1942 out := graphql.NewFieldSet(fields)
1943 var invalids uint32
1944 for i, field := range fields {
1945 switch field.Name {
1946 case "__typename":
1947 out.Values[i] = graphql.MarshalString("__Field")
1948 case "name":
1949
1950 out.Values[i] = ec.___Field_name(ctx, field, obj)
1951
1952 if out.Values[i] == graphql.Null {
1953 invalids++
1954 }
1955 case "description":
1956
1957 out.Values[i] = ec.___Field_description(ctx, field, obj)
1958
1959 case "args":
1960
1961 out.Values[i] = ec.___Field_args(ctx, field, obj)
1962
1963 if out.Values[i] == graphql.Null {
1964 invalids++
1965 }
1966 case "type":
1967
1968 out.Values[i] = ec.___Field_type(ctx, field, obj)
1969
1970 if out.Values[i] == graphql.Null {
1971 invalids++
1972 }
1973 case "isDeprecated":
1974
1975 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
1976
1977 if out.Values[i] == graphql.Null {
1978 invalids++
1979 }
1980 case "deprecationReason":
1981
1982 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
1983
1984 default:
1985 panic("unknown field " + strconv.Quote(field.Name))
1986 }
1987 }
1988 out.Dispatch()
1989 if invalids > 0 {
1990 return graphql.Null
1991 }
1992 return out
1993}
1994
1995var __InputValueImplementors = []string{"__InputValue"}
1996
1997func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
1998 fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
1999 out := graphql.NewFieldSet(fields)
2000 var invalids uint32
2001 for i, field := range fields {
2002 switch field.Name {
2003 case "__typename":
2004 out.Values[i] = graphql.MarshalString("__InputValue")
2005 case "name":
2006
2007 out.Values[i] = ec.___InputValue_name(ctx, field, obj)
2008
2009 if out.Values[i] == graphql.Null {
2010 invalids++
2011 }
2012 case "description":
2013
2014 out.Values[i] = ec.___InputValue_description(ctx, field, obj)
2015
2016 case "type":
2017
2018 out.Values[i] = ec.___InputValue_type(ctx, field, obj)
2019
2020 if out.Values[i] == graphql.Null {
2021 invalids++
2022 }
2023 case "defaultValue":
2024
2025 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
2026
2027 default:
2028 panic("unknown field " + strconv.Quote(field.Name))
2029 }
2030 }
2031 out.Dispatch()
2032 if invalids > 0 {
2033 return graphql.Null
2034 }
2035 return out
2036}
2037
2038var __SchemaImplementors = []string{"__Schema"}
2039
2040func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
2041 fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
2042 out := graphql.NewFieldSet(fields)
2043 var invalids uint32
2044 for i, field := range fields {
2045 switch field.Name {
2046 case "__typename":
2047 out.Values[i] = graphql.MarshalString("__Schema")
2048 case "description":
2049
2050 out.Values[i] = ec.___Schema_description(ctx, field, obj)
2051
2052 case "types":
2053
2054 out.Values[i] = ec.___Schema_types(ctx, field, obj)
2055
2056 if out.Values[i] == graphql.Null {
2057 invalids++
2058 }
2059 case "queryType":
2060
2061 out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
2062
2063 if out.Values[i] == graphql.Null {
2064 invalids++
2065 }
2066 case "mutationType":
2067
2068 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
2069
2070 case "subscriptionType":
2071
2072 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
2073
2074 case "directives":
2075
2076 out.Values[i] = ec.___Schema_directives(ctx, field, obj)
2077
2078 if out.Values[i] == graphql.Null {
2079 invalids++
2080 }
2081 default:
2082 panic("unknown field " + strconv.Quote(field.Name))
2083 }
2084 }
2085 out.Dispatch()
2086 if invalids > 0 {
2087 return graphql.Null
2088 }
2089 return out
2090}
2091
2092var __TypeImplementors = []string{"__Type"}
2093
2094func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
2095 fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
2096 out := graphql.NewFieldSet(fields)
2097 var invalids uint32
2098 for i, field := range fields {
2099 switch field.Name {
2100 case "__typename":
2101 out.Values[i] = graphql.MarshalString("__Type")
2102 case "kind":
2103
2104 out.Values[i] = ec.___Type_kind(ctx, field, obj)
2105
2106 if out.Values[i] == graphql.Null {
2107 invalids++
2108 }
2109 case "name":
2110
2111 out.Values[i] = ec.___Type_name(ctx, field, obj)
2112
2113 case "description":
2114
2115 out.Values[i] = ec.___Type_description(ctx, field, obj)
2116
2117 case "fields":
2118
2119 out.Values[i] = ec.___Type_fields(ctx, field, obj)
2120
2121 case "interfaces":
2122
2123 out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
2124
2125 case "possibleTypes":
2126
2127 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
2128
2129 case "enumValues":
2130
2131 out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
2132
2133 case "inputFields":
2134
2135 out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
2136
2137 case "ofType":
2138
2139 out.Values[i] = ec.___Type_ofType(ctx, field, obj)
2140
2141 case "specifiedByURL":
2142
2143 out.Values[i] = ec.___Type_specifiedByURL(ctx, field, obj)
2144
2145 default:
2146 panic("unknown field " + strconv.Quote(field.Name))
2147 }
2148 }
2149 out.Dispatch()
2150 if invalids > 0 {
2151 return graphql.Null
2152 }
2153 return out
2154}
2155
2156// endregion **************************** object.gotpl ****************************
2157
2158// region ***************************** type.gotpl *****************************
2159
2160func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
2161 res, err := graphql.UnmarshalBoolean(v)
2162 return res, graphql.ErrorOnPath(ctx, err)
2163}
2164
2165func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
2166 res := graphql.MarshalBoolean(v)
2167 if res == graphql.Null {
2168 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2169 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2170 }
2171 }
2172 return res
2173}
2174
2175func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
2176 res, err := graphql.UnmarshalInt(v)
2177 return res, graphql.ErrorOnPath(ctx, err)
2178}
2179
2180func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
2181 res := graphql.MarshalInt(v)
2182 if res == graphql.Null {
2183 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2184 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2185 }
2186 }
2187 return res
2188}
2189
2190func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
2191 res, err := graphql.UnmarshalString(v)
2192 return res, graphql.ErrorOnPath(ctx, err)
2193}
2194
2195func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
2196 res := graphql.MarshalString(v)
2197 if res == graphql.Null {
2198 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2199 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2200 }
2201 }
2202 return res
2203}
2204
2205func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
2206 return ec.___Directive(ctx, sel, &v)
2207}
2208
2209func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
2210 ret := make(graphql.Array, len(v))
2211 var wg sync.WaitGroup
2212 isLen1 := len(v) == 1
2213 if !isLen1 {
2214 wg.Add(len(v))
2215 }
2216 for i := range v {
2217 i := i
2218 fc := &graphql.FieldContext{
2219 Index: &i,
2220 Result: &v[i],
2221 }
2222 ctx := graphql.WithFieldContext(ctx, fc)
2223 f := func(i int) {
2224 defer func() {
2225 if r := recover(); r != nil {
2226 ec.Error(ctx, ec.Recover(ctx, r))
2227 ret = nil
2228 }
2229 }()
2230 if !isLen1 {
2231 defer wg.Done()
2232 }
2233 ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
2234 }
2235 if isLen1 {
2236 f(i)
2237 } else {
2238 go f(i)
2239 }
2240
2241 }
2242 wg.Wait()
2243
2244 for _, e := range ret {
2245 if e == graphql.Null {
2246 return graphql.Null
2247 }
2248 }
2249
2250 return ret
2251}
2252
2253func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
2254 res, err := graphql.UnmarshalString(v)
2255 return res, graphql.ErrorOnPath(ctx, err)
2256}
2257
2258func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
2259 res := graphql.MarshalString(v)
2260 if res == graphql.Null {
2261 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2262 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2263 }
2264 }
2265 return res
2266}
2267
2268func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
2269 var vSlice []interface{}
2270 if v != nil {
2271 vSlice = graphql.CoerceList(v)
2272 }
2273 var err error
2274 res := make([]string, len(vSlice))
2275 for i := range vSlice {
2276 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
2277 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
2278 if err != nil {
2279 return nil, err
2280 }
2281 }
2282 return res, nil
2283}
2284
2285func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
2286 ret := make(graphql.Array, len(v))
2287 var wg sync.WaitGroup
2288 isLen1 := len(v) == 1
2289 if !isLen1 {
2290 wg.Add(len(v))
2291 }
2292 for i := range v {
2293 i := i
2294 fc := &graphql.FieldContext{
2295 Index: &i,
2296 Result: &v[i],
2297 }
2298 ctx := graphql.WithFieldContext(ctx, fc)
2299 f := func(i int) {
2300 defer func() {
2301 if r := recover(); r != nil {
2302 ec.Error(ctx, ec.Recover(ctx, r))
2303 ret = nil
2304 }
2305 }()
2306 if !isLen1 {
2307 defer wg.Done()
2308 }
2309 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
2310 }
2311 if isLen1 {
2312 f(i)
2313 } else {
2314 go f(i)
2315 }
2316
2317 }
2318 wg.Wait()
2319
2320 for _, e := range ret {
2321 if e == graphql.Null {
2322 return graphql.Null
2323 }
2324 }
2325
2326 return ret
2327}
2328
2329func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
2330 return ec.___EnumValue(ctx, sel, &v)
2331}
2332
2333func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
2334 return ec.___Field(ctx, sel, &v)
2335}
2336
2337func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
2338 return ec.___InputValue(ctx, sel, &v)
2339}
2340
2341func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
2342 ret := make(graphql.Array, len(v))
2343 var wg sync.WaitGroup
2344 isLen1 := len(v) == 1
2345 if !isLen1 {
2346 wg.Add(len(v))
2347 }
2348 for i := range v {
2349 i := i
2350 fc := &graphql.FieldContext{
2351 Index: &i,
2352 Result: &v[i],
2353 }
2354 ctx := graphql.WithFieldContext(ctx, fc)
2355 f := func(i int) {
2356 defer func() {
2357 if r := recover(); r != nil {
2358 ec.Error(ctx, ec.Recover(ctx, r))
2359 ret = nil
2360 }
2361 }()
2362 if !isLen1 {
2363 defer wg.Done()
2364 }
2365 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
2366 }
2367 if isLen1 {
2368 f(i)
2369 } else {
2370 go f(i)
2371 }
2372
2373 }
2374 wg.Wait()
2375
2376 for _, e := range ret {
2377 if e == graphql.Null {
2378 return graphql.Null
2379 }
2380 }
2381
2382 return ret
2383}
2384
2385func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
2386 return ec.___Type(ctx, sel, &v)
2387}
2388
2389func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
2390 ret := make(graphql.Array, len(v))
2391 var wg sync.WaitGroup
2392 isLen1 := len(v) == 1
2393 if !isLen1 {
2394 wg.Add(len(v))
2395 }
2396 for i := range v {
2397 i := i
2398 fc := &graphql.FieldContext{
2399 Index: &i,
2400 Result: &v[i],
2401 }
2402 ctx := graphql.WithFieldContext(ctx, fc)
2403 f := func(i int) {
2404 defer func() {
2405 if r := recover(); r != nil {
2406 ec.Error(ctx, ec.Recover(ctx, r))
2407 ret = nil
2408 }
2409 }()
2410 if !isLen1 {
2411 defer wg.Done()
2412 }
2413 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
2414 }
2415 if isLen1 {
2416 f(i)
2417 } else {
2418 go f(i)
2419 }
2420
2421 }
2422 wg.Wait()
2423
2424 for _, e := range ret {
2425 if e == graphql.Null {
2426 return graphql.Null
2427 }
2428 }
2429
2430 return ret
2431}
2432
2433func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
2434 if v == nil {
2435 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2436 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2437 }
2438 return graphql.Null
2439 }
2440 return ec.___Type(ctx, sel, v)
2441}
2442
2443func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
2444 res, err := graphql.UnmarshalString(v)
2445 return res, graphql.ErrorOnPath(ctx, err)
2446}
2447
2448func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
2449 res := graphql.MarshalString(v)
2450 if res == graphql.Null {
2451 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2452 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2453 }
2454 }
2455 return res
2456}
2457
2458func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
2459 res, err := graphql.UnmarshalBoolean(v)
2460 return res, graphql.ErrorOnPath(ctx, err)
2461}
2462
2463func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
2464 res := graphql.MarshalBoolean(v)
2465 return res
2466}
2467
2468func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
2469 if v == nil {
2470 return nil, nil
2471 }
2472 res, err := graphql.UnmarshalBoolean(v)
2473 return &res, graphql.ErrorOnPath(ctx, err)
2474}
2475
2476func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
2477 if v == nil {
2478 return graphql.Null
2479 }
2480 res := graphql.MarshalBoolean(*v)
2481 return res
2482}
2483
2484func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
2485 if v == nil {
2486 return nil, nil
2487 }
2488 res, err := graphql.UnmarshalInt(v)
2489 return &res, graphql.ErrorOnPath(ctx, err)
2490}
2491
2492func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
2493 if v == nil {
2494 return graphql.Null
2495 }
2496 res := graphql.MarshalInt(*v)
2497 return res
2498}
2499
2500func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
2501 res, err := graphql.UnmarshalString(v)
2502 return res, graphql.ErrorOnPath(ctx, err)
2503}
2504
2505func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
2506 res := graphql.MarshalString(v)
2507 return res
2508}
2509
2510func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
2511 if v == nil {
2512 return nil, nil
2513 }
2514 var vSlice []interface{}
2515 if v != nil {
2516 vSlice = graphql.CoerceList(v)
2517 }
2518 var err error
2519 res := make([]string, len(vSlice))
2520 for i := range vSlice {
2521 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
2522 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
2523 if err != nil {
2524 return nil, err
2525 }
2526 }
2527 return res, nil
2528}
2529
2530func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
2531 if v == nil {
2532 return graphql.Null
2533 }
2534 ret := make(graphql.Array, len(v))
2535 for i := range v {
2536 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
2537 }
2538
2539 for _, e := range ret {
2540 if e == graphql.Null {
2541 return graphql.Null
2542 }
2543 }
2544
2545 return ret
2546}
2547
2548func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
2549 if v == nil {
2550 return nil, nil
2551 }
2552 res, err := graphql.UnmarshalString(v)
2553 return &res, graphql.ErrorOnPath(ctx, err)
2554}
2555
2556func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
2557 if v == nil {
2558 return graphql.Null
2559 }
2560 res := graphql.MarshalString(*v)
2561 return res
2562}
2563
2564func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
2565 if v == nil {
2566 return graphql.Null
2567 }
2568 ret := make(graphql.Array, len(v))
2569 var wg sync.WaitGroup
2570 isLen1 := len(v) == 1
2571 if !isLen1 {
2572 wg.Add(len(v))
2573 }
2574 for i := range v {
2575 i := i
2576 fc := &graphql.FieldContext{
2577 Index: &i,
2578 Result: &v[i],
2579 }
2580 ctx := graphql.WithFieldContext(ctx, fc)
2581 f := func(i int) {
2582 defer func() {
2583 if r := recover(); r != nil {
2584 ec.Error(ctx, ec.Recover(ctx, r))
2585 ret = nil
2586 }
2587 }()
2588 if !isLen1 {
2589 defer wg.Done()
2590 }
2591 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
2592 }
2593 if isLen1 {
2594 f(i)
2595 } else {
2596 go f(i)
2597 }
2598
2599 }
2600 wg.Wait()
2601
2602 for _, e := range ret {
2603 if e == graphql.Null {
2604 return graphql.Null
2605 }
2606 }
2607
2608 return ret
2609}
2610
2611func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
2612 if v == nil {
2613 return graphql.Null
2614 }
2615 ret := make(graphql.Array, len(v))
2616 var wg sync.WaitGroup
2617 isLen1 := len(v) == 1
2618 if !isLen1 {
2619 wg.Add(len(v))
2620 }
2621 for i := range v {
2622 i := i
2623 fc := &graphql.FieldContext{
2624 Index: &i,
2625 Result: &v[i],
2626 }
2627 ctx := graphql.WithFieldContext(ctx, fc)
2628 f := func(i int) {
2629 defer func() {
2630 if r := recover(); r != nil {
2631 ec.Error(ctx, ec.Recover(ctx, r))
2632 ret = nil
2633 }
2634 }()
2635 if !isLen1 {
2636 defer wg.Done()
2637 }
2638 ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
2639 }
2640 if isLen1 {
2641 f(i)
2642 } else {
2643 go f(i)
2644 }
2645
2646 }
2647 wg.Wait()
2648
2649 for _, e := range ret {
2650 if e == graphql.Null {
2651 return graphql.Null
2652 }
2653 }
2654
2655 return ret
2656}
2657
2658func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
2659 if v == nil {
2660 return graphql.Null
2661 }
2662 ret := make(graphql.Array, len(v))
2663 var wg sync.WaitGroup
2664 isLen1 := len(v) == 1
2665 if !isLen1 {
2666 wg.Add(len(v))
2667 }
2668 for i := range v {
2669 i := i
2670 fc := &graphql.FieldContext{
2671 Index: &i,
2672 Result: &v[i],
2673 }
2674 ctx := graphql.WithFieldContext(ctx, fc)
2675 f := func(i int) {
2676 defer func() {
2677 if r := recover(); r != nil {
2678 ec.Error(ctx, ec.Recover(ctx, r))
2679 ret = nil
2680 }
2681 }()
2682 if !isLen1 {
2683 defer wg.Done()
2684 }
2685 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
2686 }
2687 if isLen1 {
2688 f(i)
2689 } else {
2690 go f(i)
2691 }
2692
2693 }
2694 wg.Wait()
2695
2696 for _, e := range ret {
2697 if e == graphql.Null {
2698 return graphql.Null
2699 }
2700 }
2701
2702 return ret
2703}
2704
2705func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
2706 if v == nil {
2707 return graphql.Null
2708 }
2709 return ec.___Schema(ctx, sel, v)
2710}
2711
2712func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
2713 if v == nil {
2714 return graphql.Null
2715 }
2716 ret := make(graphql.Array, len(v))
2717 var wg sync.WaitGroup
2718 isLen1 := len(v) == 1
2719 if !isLen1 {
2720 wg.Add(len(v))
2721 }
2722 for i := range v {
2723 i := i
2724 fc := &graphql.FieldContext{
2725 Index: &i,
2726 Result: &v[i],
2727 }
2728 ctx := graphql.WithFieldContext(ctx, fc)
2729 f := func(i int) {
2730 defer func() {
2731 if r := recover(); r != nil {
2732 ec.Error(ctx, ec.Recover(ctx, r))
2733 ret = nil
2734 }
2735 }()
2736 if !isLen1 {
2737 defer wg.Done()
2738 }
2739 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
2740 }
2741 if isLen1 {
2742 f(i)
2743 } else {
2744 go f(i)
2745 }
2746
2747 }
2748 wg.Wait()
2749
2750 for _, e := range ret {
2751 if e == graphql.Null {
2752 return graphql.Null
2753 }
2754 }
2755
2756 return ret
2757}
2758
2759func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
2760 if v == nil {
2761 return graphql.Null
2762 }
2763 return ec.___Type(ctx, sel, v)
2764}
2765
2766// endregion ***************************** type.gotpl *****************************