1
2
3 package generated
4
5 import (
6 "context"
7 "errors"
8 "fmt"
9 "strings"
10 "sync"
11
12 "github.com/99designs/gqlgen/plugin/federation/fedruntime"
13 )
14
15 var (
16 ErrUnknownType = errors.New("unknown type")
17 ErrTypeNotFound = errors.New("type not found")
18 )
19
20 func (ec *executionContext) __resolve__service(ctx context.Context) (fedruntime.Service, error) {
21 if ec.DisableIntrospection {
22 return fedruntime.Service{}, errors.New("federated introspection disabled")
23 }
24
25 var sdl []string
26
27 for _, src := range sources {
28 if src.BuiltIn {
29 continue
30 }
31 sdl = append(sdl, src.Input)
32 }
33
34 return fedruntime.Service{
35 SDL: strings.Join(sdl, "\n"),
36 }, nil
37 }
38
39 func (ec *executionContext) __resolve_entities(ctx context.Context, representations []map[string]interface{}) []fedruntime.Entity {
40 list := make([]fedruntime.Entity, len(representations))
41
42 repsMap := map[string]struct {
43 i []int
44 r []map[string]interface{}
45 }{}
46
47
48
49 buildRepresentationGroups := func(reps []map[string]interface{}) {
50 for i, rep := range reps {
51 typeName, ok := rep["__typename"].(string)
52 if !ok {
53
54
55 ec.Error(ctx, errors.New("__typename must be an existing string"))
56 continue
57 }
58
59 _r := repsMap[typeName]
60 _r.i = append(_r.i, i)
61 _r.r = append(_r.r, rep)
62 repsMap[typeName] = _r
63 }
64 }
65
66 isMulti := func(typeName string) bool {
67 switch typeName {
68 case "MultiHello":
69 return true
70 case "MultiHelloMultipleRequires":
71 return true
72 case "MultiHelloRequires":
73 return true
74 case "MultiHelloWithError":
75 return true
76 case "MultiPlanetRequiresNested":
77 return true
78 default:
79 return false
80 }
81 }
82
83 resolveEntity := func(ctx context.Context, typeName string, rep map[string]interface{}, idx []int, i int) (err error) {
84
85
86 defer func() {
87 if r := recover(); r != nil {
88 err = ec.Recover(ctx, r)
89 }
90 }()
91
92 switch typeName {
93 case "Hello":
94 resolverName, err := entityResolverNameForHello(ctx, rep)
95 if err != nil {
96 return fmt.Errorf(`finding resolver for Entity "Hello": %w`, err)
97 }
98 switch resolverName {
99
100 case "findHelloByName":
101 id0, err := ec.unmarshalNString2string(ctx, rep["name"])
102 if err != nil {
103 return fmt.Errorf(`unmarshalling param 0 for findHelloByName(): %w`, err)
104 }
105 entity, err := ec.resolvers.Entity().FindHelloByName(ctx, id0)
106 if err != nil {
107 return fmt.Errorf(`resolving Entity "Hello": %w`, err)
108 }
109
110 list[idx[i]] = entity
111 return nil
112 }
113 case "HelloMultiSingleKeys":
114 resolverName, err := entityResolverNameForHelloMultiSingleKeys(ctx, rep)
115 if err != nil {
116 return fmt.Errorf(`finding resolver for Entity "HelloMultiSingleKeys": %w`, err)
117 }
118 switch resolverName {
119
120 case "findHelloMultiSingleKeysByKey1AndKey2":
121 id0, err := ec.unmarshalNString2string(ctx, rep["key1"])
122 if err != nil {
123 return fmt.Errorf(`unmarshalling param 0 for findHelloMultiSingleKeysByKey1AndKey2(): %w`, err)
124 }
125 id1, err := ec.unmarshalNString2string(ctx, rep["key2"])
126 if err != nil {
127 return fmt.Errorf(`unmarshalling param 1 for findHelloMultiSingleKeysByKey1AndKey2(): %w`, err)
128 }
129 entity, err := ec.resolvers.Entity().FindHelloMultiSingleKeysByKey1AndKey2(ctx, id0, id1)
130 if err != nil {
131 return fmt.Errorf(`resolving Entity "HelloMultiSingleKeys": %w`, err)
132 }
133
134 list[idx[i]] = entity
135 return nil
136 }
137 case "HelloWithErrors":
138 resolverName, err := entityResolverNameForHelloWithErrors(ctx, rep)
139 if err != nil {
140 return fmt.Errorf(`finding resolver for Entity "HelloWithErrors": %w`, err)
141 }
142 switch resolverName {
143
144 case "findHelloWithErrorsByName":
145 id0, err := ec.unmarshalNString2string(ctx, rep["name"])
146 if err != nil {
147 return fmt.Errorf(`unmarshalling param 0 for findHelloWithErrorsByName(): %w`, err)
148 }
149 entity, err := ec.resolvers.Entity().FindHelloWithErrorsByName(ctx, id0)
150 if err != nil {
151 return fmt.Errorf(`resolving Entity "HelloWithErrors": %w`, err)
152 }
153
154 list[idx[i]] = entity
155 return nil
156 }
157 case "PlanetMultipleRequires":
158 resolverName, err := entityResolverNameForPlanetMultipleRequires(ctx, rep)
159 if err != nil {
160 return fmt.Errorf(`finding resolver for Entity "PlanetMultipleRequires": %w`, err)
161 }
162 switch resolverName {
163
164 case "findPlanetMultipleRequiresByName":
165 id0, err := ec.unmarshalNString2string(ctx, rep["name"])
166 if err != nil {
167 return fmt.Errorf(`unmarshalling param 0 for findPlanetMultipleRequiresByName(): %w`, err)
168 }
169 entity, err := ec.resolvers.Entity().FindPlanetMultipleRequiresByName(ctx, id0)
170 if err != nil {
171 return fmt.Errorf(`resolving Entity "PlanetMultipleRequires": %w`, err)
172 }
173
174 err = ec.PopulatePlanetMultipleRequiresRequires(ctx, entity, rep)
175 if err != nil {
176 return fmt.Errorf(`populating requires for Entity "PlanetMultipleRequires": %w`, err)
177 }
178 list[idx[i]] = entity
179 return nil
180 }
181 case "PlanetRequires":
182 resolverName, err := entityResolverNameForPlanetRequires(ctx, rep)
183 if err != nil {
184 return fmt.Errorf(`finding resolver for Entity "PlanetRequires": %w`, err)
185 }
186 switch resolverName {
187
188 case "findPlanetRequiresByName":
189 id0, err := ec.unmarshalNString2string(ctx, rep["name"])
190 if err != nil {
191 return fmt.Errorf(`unmarshalling param 0 for findPlanetRequiresByName(): %w`, err)
192 }
193 entity, err := ec.resolvers.Entity().FindPlanetRequiresByName(ctx, id0)
194 if err != nil {
195 return fmt.Errorf(`resolving Entity "PlanetRequires": %w`, err)
196 }
197
198 err = ec.PopulatePlanetRequiresRequires(ctx, entity, rep)
199 if err != nil {
200 return fmt.Errorf(`populating requires for Entity "PlanetRequires": %w`, err)
201 }
202 list[idx[i]] = entity
203 return nil
204 }
205 case "PlanetRequiresNested":
206 resolverName, err := entityResolverNameForPlanetRequiresNested(ctx, rep)
207 if err != nil {
208 return fmt.Errorf(`finding resolver for Entity "PlanetRequiresNested": %w`, err)
209 }
210 switch resolverName {
211
212 case "findPlanetRequiresNestedByName":
213 id0, err := ec.unmarshalNString2string(ctx, rep["name"])
214 if err != nil {
215 return fmt.Errorf(`unmarshalling param 0 for findPlanetRequiresNestedByName(): %w`, err)
216 }
217 entity, err := ec.resolvers.Entity().FindPlanetRequiresNestedByName(ctx, id0)
218 if err != nil {
219 return fmt.Errorf(`resolving Entity "PlanetRequiresNested": %w`, err)
220 }
221
222 err = ec.PopulatePlanetRequiresNestedRequires(ctx, entity, rep)
223 if err != nil {
224 return fmt.Errorf(`populating requires for Entity "PlanetRequiresNested": %w`, err)
225 }
226 list[idx[i]] = entity
227 return nil
228 }
229 case "World":
230 resolverName, err := entityResolverNameForWorld(ctx, rep)
231 if err != nil {
232 return fmt.Errorf(`finding resolver for Entity "World": %w`, err)
233 }
234 switch resolverName {
235
236 case "findWorldByHelloNameAndFoo":
237 id0, err := ec.unmarshalNString2string(ctx, rep["hello"].(map[string]interface{})["name"])
238 if err != nil {
239 return fmt.Errorf(`unmarshalling param 0 for findWorldByHelloNameAndFoo(): %w`, err)
240 }
241 id1, err := ec.unmarshalNString2string(ctx, rep["foo"])
242 if err != nil {
243 return fmt.Errorf(`unmarshalling param 1 for findWorldByHelloNameAndFoo(): %w`, err)
244 }
245 entity, err := ec.resolvers.Entity().FindWorldByHelloNameAndFoo(ctx, id0, id1)
246 if err != nil {
247 return fmt.Errorf(`resolving Entity "World": %w`, err)
248 }
249
250 list[idx[i]] = entity
251 return nil
252 }
253 case "WorldName":
254 resolverName, err := entityResolverNameForWorldName(ctx, rep)
255 if err != nil {
256 return fmt.Errorf(`finding resolver for Entity "WorldName": %w`, err)
257 }
258 switch resolverName {
259
260 case "findWorldNameByName":
261 id0, err := ec.unmarshalNString2string(ctx, rep["name"])
262 if err != nil {
263 return fmt.Errorf(`unmarshalling param 0 for findWorldNameByName(): %w`, err)
264 }
265 entity, err := ec.resolvers.Entity().FindWorldNameByName(ctx, id0)
266 if err != nil {
267 return fmt.Errorf(`resolving Entity "WorldName": %w`, err)
268 }
269
270 list[idx[i]] = entity
271 return nil
272 }
273 case "WorldWithMultipleKeys":
274 resolverName, err := entityResolverNameForWorldWithMultipleKeys(ctx, rep)
275 if err != nil {
276 return fmt.Errorf(`finding resolver for Entity "WorldWithMultipleKeys": %w`, err)
277 }
278 switch resolverName {
279
280 case "findWorldWithMultipleKeysByHelloNameAndFoo":
281 id0, err := ec.unmarshalNString2string(ctx, rep["hello"].(map[string]interface{})["name"])
282 if err != nil {
283 return fmt.Errorf(`unmarshalling param 0 for findWorldWithMultipleKeysByHelloNameAndFoo(): %w`, err)
284 }
285 id1, err := ec.unmarshalNString2string(ctx, rep["foo"])
286 if err != nil {
287 return fmt.Errorf(`unmarshalling param 1 for findWorldWithMultipleKeysByHelloNameAndFoo(): %w`, err)
288 }
289 entity, err := ec.resolvers.Entity().FindWorldWithMultipleKeysByHelloNameAndFoo(ctx, id0, id1)
290 if err != nil {
291 return fmt.Errorf(`resolving Entity "WorldWithMultipleKeys": %w`, err)
292 }
293
294 list[idx[i]] = entity
295 return nil
296 case "findWorldWithMultipleKeysByBar":
297 id0, err := ec.unmarshalNInt2int(ctx, rep["bar"])
298 if err != nil {
299 return fmt.Errorf(`unmarshalling param 0 for findWorldWithMultipleKeysByBar(): %w`, err)
300 }
301 entity, err := ec.resolvers.Entity().FindWorldWithMultipleKeysByBar(ctx, id0)
302 if err != nil {
303 return fmt.Errorf(`resolving Entity "WorldWithMultipleKeys": %w`, err)
304 }
305
306 list[idx[i]] = entity
307 return nil
308 }
309
310 }
311 return fmt.Errorf("%w: %s", ErrUnknownType, typeName)
312 }
313
314 resolveManyEntities := func(ctx context.Context, typeName string, reps []map[string]interface{}, idx []int) (err error) {
315
316
317 defer func() {
318 if r := recover(); r != nil {
319 err = ec.Recover(ctx, r)
320 }
321 }()
322
323 switch typeName {
324
325 case "MultiHello":
326 resolverName, err := entityResolverNameForMultiHello(ctx, reps[0])
327 if err != nil {
328 return fmt.Errorf(`finding resolver for Entity "MultiHello": %w`, err)
329 }
330 switch resolverName {
331
332 case "findManyMultiHelloByNames":
333 _reps := make([]*MultiHelloByNamesInput, len(reps))
334
335 for i, rep := range reps {
336 id0, err := ec.unmarshalNString2string(ctx, rep["name"])
337 if err != nil {
338 return errors.New(fmt.Sprintf("Field %s undefined in schema.", "name"))
339 }
340
341 _reps[i] = &MultiHelloByNamesInput{
342 Name: id0,
343 }
344 }
345
346 entities, err := ec.resolvers.Entity().FindManyMultiHelloByNames(ctx, _reps)
347 if err != nil {
348 return err
349 }
350
351 for i, entity := range entities {
352 list[idx[i]] = entity
353 }
354 return nil
355
356 default:
357 return fmt.Errorf("unknown resolver: %s", resolverName)
358 }
359
360 case "MultiHelloMultipleRequires":
361 resolverName, err := entityResolverNameForMultiHelloMultipleRequires(ctx, reps[0])
362 if err != nil {
363 return fmt.Errorf(`finding resolver for Entity "MultiHelloMultipleRequires": %w`, err)
364 }
365 switch resolverName {
366
367 case "findManyMultiHelloMultipleRequiresByNames":
368 _reps := make([]*MultiHelloMultipleRequiresByNamesInput, len(reps))
369
370 for i, rep := range reps {
371 id0, err := ec.unmarshalNString2string(ctx, rep["name"])
372 if err != nil {
373 return errors.New(fmt.Sprintf("Field %s undefined in schema.", "name"))
374 }
375
376 _reps[i] = &MultiHelloMultipleRequiresByNamesInput{
377 Name: id0,
378 }
379 }
380
381 entities, err := ec.resolvers.Entity().FindManyMultiHelloMultipleRequiresByNames(ctx, _reps)
382 if err != nil {
383 return err
384 }
385
386 for i, entity := range entities {
387 entity.Key1, err = ec.unmarshalNString2string(ctx, reps[i]["key1"])
388 if err != nil {
389 return err
390 }
391 entity.Key2, err = ec.unmarshalNString2string(ctx, reps[i]["key2"])
392 if err != nil {
393 return err
394 }
395 list[idx[i]] = entity
396 }
397 return nil
398
399 default:
400 return fmt.Errorf("unknown resolver: %s", resolverName)
401 }
402
403 case "MultiHelloRequires":
404 resolverName, err := entityResolverNameForMultiHelloRequires(ctx, reps[0])
405 if err != nil {
406 return fmt.Errorf(`finding resolver for Entity "MultiHelloRequires": %w`, err)
407 }
408 switch resolverName {
409
410 case "findManyMultiHelloRequiresByNames":
411 _reps := make([]*MultiHelloRequiresByNamesInput, len(reps))
412
413 for i, rep := range reps {
414 id0, err := ec.unmarshalNString2string(ctx, rep["name"])
415 if err != nil {
416 return errors.New(fmt.Sprintf("Field %s undefined in schema.", "name"))
417 }
418
419 _reps[i] = &MultiHelloRequiresByNamesInput{
420 Name: id0,
421 }
422 }
423
424 entities, err := ec.resolvers.Entity().FindManyMultiHelloRequiresByNames(ctx, _reps)
425 if err != nil {
426 return err
427 }
428
429 for i, entity := range entities {
430 entity.Key1, err = ec.unmarshalNString2string(ctx, reps[i]["key1"])
431 if err != nil {
432 return err
433 }
434 list[idx[i]] = entity
435 }
436 return nil
437
438 default:
439 return fmt.Errorf("unknown resolver: %s", resolverName)
440 }
441
442 case "MultiHelloWithError":
443 resolverName, err := entityResolverNameForMultiHelloWithError(ctx, reps[0])
444 if err != nil {
445 return fmt.Errorf(`finding resolver for Entity "MultiHelloWithError": %w`, err)
446 }
447 switch resolverName {
448
449 case "findManyMultiHelloWithErrorByNames":
450 _reps := make([]*MultiHelloWithErrorByNamesInput, len(reps))
451
452 for i, rep := range reps {
453 id0, err := ec.unmarshalNString2string(ctx, rep["name"])
454 if err != nil {
455 return errors.New(fmt.Sprintf("Field %s undefined in schema.", "name"))
456 }
457
458 _reps[i] = &MultiHelloWithErrorByNamesInput{
459 Name: id0,
460 }
461 }
462
463 entities, err := ec.resolvers.Entity().FindManyMultiHelloWithErrorByNames(ctx, _reps)
464 if err != nil {
465 return err
466 }
467
468 for i, entity := range entities {
469 list[idx[i]] = entity
470 }
471 return nil
472
473 default:
474 return fmt.Errorf("unknown resolver: %s", resolverName)
475 }
476
477 case "MultiPlanetRequiresNested":
478 resolverName, err := entityResolverNameForMultiPlanetRequiresNested(ctx, reps[0])
479 if err != nil {
480 return fmt.Errorf(`finding resolver for Entity "MultiPlanetRequiresNested": %w`, err)
481 }
482 switch resolverName {
483
484 case "findManyMultiPlanetRequiresNestedByNames":
485 _reps := make([]*MultiPlanetRequiresNestedByNamesInput, len(reps))
486
487 for i, rep := range reps {
488 id0, err := ec.unmarshalNString2string(ctx, rep["name"])
489 if err != nil {
490 return errors.New(fmt.Sprintf("Field %s undefined in schema.", "name"))
491 }
492
493 _reps[i] = &MultiPlanetRequiresNestedByNamesInput{
494 Name: id0,
495 }
496 }
497
498 entities, err := ec.resolvers.Entity().FindManyMultiPlanetRequiresNestedByNames(ctx, _reps)
499 if err != nil {
500 return err
501 }
502
503 for i, entity := range entities {
504 entity.World.Foo, err = ec.unmarshalNString2string(ctx, reps[i]["world"].(map[string]interface{})["foo"])
505 if err != nil {
506 return err
507 }
508 list[idx[i]] = entity
509 }
510 return nil
511
512 default:
513 return fmt.Errorf("unknown resolver: %s", resolverName)
514 }
515
516 default:
517 return errors.New("unknown type: " + typeName)
518 }
519 }
520
521 resolveEntityGroup := func(typeName string, reps []map[string]interface{}, idx []int) {
522 if isMulti(typeName) {
523 err := resolveManyEntities(ctx, typeName, reps, idx)
524 if err != nil {
525 ec.Error(ctx, err)
526 }
527 } else {
528
529
530 var e sync.WaitGroup
531 e.Add(len(reps))
532 for i, rep := range reps {
533 i, rep := i, rep
534 go func(i int, rep map[string]interface{}) {
535 err := resolveEntity(ctx, typeName, rep, idx, i)
536 if err != nil {
537 ec.Error(ctx, err)
538 }
539 e.Done()
540 }(i, rep)
541 }
542 e.Wait()
543 }
544 }
545 buildRepresentationGroups(representations)
546
547 switch len(repsMap) {
548 case 0:
549 return list
550 case 1:
551 for typeName, reps := range repsMap {
552 resolveEntityGroup(typeName, reps.r, reps.i)
553 }
554 return list
555 default:
556 var g sync.WaitGroup
557 g.Add(len(repsMap))
558 for typeName, reps := range repsMap {
559 go func(typeName string, reps []map[string]interface{}, idx []int) {
560 resolveEntityGroup(typeName, reps, idx)
561 g.Done()
562 }(typeName, reps.r, reps.i)
563 }
564 g.Wait()
565 return list
566 }
567 }
568
569 func entityResolverNameForHello(ctx context.Context, rep map[string]interface{}) (string, error) {
570 for {
571 var (
572 m map[string]interface{}
573 val interface{}
574 ok bool
575 )
576 _ = val
577 m = rep
578 if _, ok = m["name"]; !ok {
579 break
580 }
581 return "findHelloByName", nil
582 }
583 return "", fmt.Errorf("%w for Hello", ErrTypeNotFound)
584 }
585
586 func entityResolverNameForHelloMultiSingleKeys(ctx context.Context, rep map[string]interface{}) (string, error) {
587 for {
588 var (
589 m map[string]interface{}
590 val interface{}
591 ok bool
592 )
593 _ = val
594 m = rep
595 if _, ok = m["key1"]; !ok {
596 break
597 }
598 m = rep
599 if _, ok = m["key2"]; !ok {
600 break
601 }
602 return "findHelloMultiSingleKeysByKey1AndKey2", nil
603 }
604 return "", fmt.Errorf("%w for HelloMultiSingleKeys", ErrTypeNotFound)
605 }
606
607 func entityResolverNameForHelloWithErrors(ctx context.Context, rep map[string]interface{}) (string, error) {
608 for {
609 var (
610 m map[string]interface{}
611 val interface{}
612 ok bool
613 )
614 _ = val
615 m = rep
616 if _, ok = m["name"]; !ok {
617 break
618 }
619 return "findHelloWithErrorsByName", nil
620 }
621 return "", fmt.Errorf("%w for HelloWithErrors", ErrTypeNotFound)
622 }
623
624 func entityResolverNameForMultiHello(ctx context.Context, rep map[string]interface{}) (string, error) {
625 for {
626 var (
627 m map[string]interface{}
628 val interface{}
629 ok bool
630 )
631 _ = val
632 m = rep
633 if _, ok = m["name"]; !ok {
634 break
635 }
636 return "findManyMultiHelloByNames", nil
637 }
638 return "", fmt.Errorf("%w for MultiHello", ErrTypeNotFound)
639 }
640
641 func entityResolverNameForMultiHelloMultipleRequires(ctx context.Context, rep map[string]interface{}) (string, error) {
642 for {
643 var (
644 m map[string]interface{}
645 val interface{}
646 ok bool
647 )
648 _ = val
649 m = rep
650 if _, ok = m["name"]; !ok {
651 break
652 }
653 return "findManyMultiHelloMultipleRequiresByNames", nil
654 }
655 return "", fmt.Errorf("%w for MultiHelloMultipleRequires", ErrTypeNotFound)
656 }
657
658 func entityResolverNameForMultiHelloRequires(ctx context.Context, rep map[string]interface{}) (string, error) {
659 for {
660 var (
661 m map[string]interface{}
662 val interface{}
663 ok bool
664 )
665 _ = val
666 m = rep
667 if _, ok = m["name"]; !ok {
668 break
669 }
670 return "findManyMultiHelloRequiresByNames", nil
671 }
672 return "", fmt.Errorf("%w for MultiHelloRequires", ErrTypeNotFound)
673 }
674
675 func entityResolverNameForMultiHelloWithError(ctx context.Context, rep map[string]interface{}) (string, error) {
676 for {
677 var (
678 m map[string]interface{}
679 val interface{}
680 ok bool
681 )
682 _ = val
683 m = rep
684 if _, ok = m["name"]; !ok {
685 break
686 }
687 return "findManyMultiHelloWithErrorByNames", nil
688 }
689 return "", fmt.Errorf("%w for MultiHelloWithError", ErrTypeNotFound)
690 }
691
692 func entityResolverNameForMultiPlanetRequiresNested(ctx context.Context, rep map[string]interface{}) (string, error) {
693 for {
694 var (
695 m map[string]interface{}
696 val interface{}
697 ok bool
698 )
699 _ = val
700 m = rep
701 if _, ok = m["name"]; !ok {
702 break
703 }
704 return "findManyMultiPlanetRequiresNestedByNames", nil
705 }
706 return "", fmt.Errorf("%w for MultiPlanetRequiresNested", ErrTypeNotFound)
707 }
708
709 func entityResolverNameForPlanetMultipleRequires(ctx context.Context, rep map[string]interface{}) (string, error) {
710 for {
711 var (
712 m map[string]interface{}
713 val interface{}
714 ok bool
715 )
716 _ = val
717 m = rep
718 if _, ok = m["name"]; !ok {
719 break
720 }
721 return "findPlanetMultipleRequiresByName", nil
722 }
723 return "", fmt.Errorf("%w for PlanetMultipleRequires", ErrTypeNotFound)
724 }
725
726 func entityResolverNameForPlanetRequires(ctx context.Context, rep map[string]interface{}) (string, error) {
727 for {
728 var (
729 m map[string]interface{}
730 val interface{}
731 ok bool
732 )
733 _ = val
734 m = rep
735 if _, ok = m["name"]; !ok {
736 break
737 }
738 return "findPlanetRequiresByName", nil
739 }
740 return "", fmt.Errorf("%w for PlanetRequires", ErrTypeNotFound)
741 }
742
743 func entityResolverNameForPlanetRequiresNested(ctx context.Context, rep map[string]interface{}) (string, error) {
744 for {
745 var (
746 m map[string]interface{}
747 val interface{}
748 ok bool
749 )
750 _ = val
751 m = rep
752 if _, ok = m["name"]; !ok {
753 break
754 }
755 return "findPlanetRequiresNestedByName", nil
756 }
757 return "", fmt.Errorf("%w for PlanetRequiresNested", ErrTypeNotFound)
758 }
759
760 func entityResolverNameForWorld(ctx context.Context, rep map[string]interface{}) (string, error) {
761 for {
762 var (
763 m map[string]interface{}
764 val interface{}
765 ok bool
766 )
767 _ = val
768 m = rep
769 if val, ok = m["hello"]; !ok {
770 break
771 }
772 if m, ok = val.(map[string]interface{}); !ok {
773 break
774 }
775 if _, ok = m["name"]; !ok {
776 break
777 }
778 m = rep
779 if _, ok = m["foo"]; !ok {
780 break
781 }
782 return "findWorldByHelloNameAndFoo", nil
783 }
784 return "", fmt.Errorf("%w for World", ErrTypeNotFound)
785 }
786
787 func entityResolverNameForWorldName(ctx context.Context, rep map[string]interface{}) (string, error) {
788 for {
789 var (
790 m map[string]interface{}
791 val interface{}
792 ok bool
793 )
794 _ = val
795 m = rep
796 if _, ok = m["name"]; !ok {
797 break
798 }
799 return "findWorldNameByName", nil
800 }
801 return "", fmt.Errorf("%w for WorldName", ErrTypeNotFound)
802 }
803
804 func entityResolverNameForWorldWithMultipleKeys(ctx context.Context, rep map[string]interface{}) (string, error) {
805 for {
806 var (
807 m map[string]interface{}
808 val interface{}
809 ok bool
810 )
811 _ = val
812 m = rep
813 if val, ok = m["hello"]; !ok {
814 break
815 }
816 if m, ok = val.(map[string]interface{}); !ok {
817 break
818 }
819 if _, ok = m["name"]; !ok {
820 break
821 }
822 m = rep
823 if _, ok = m["foo"]; !ok {
824 break
825 }
826 return "findWorldWithMultipleKeysByHelloNameAndFoo", nil
827 }
828 for {
829 var (
830 m map[string]interface{}
831 val interface{}
832 ok bool
833 )
834 _ = val
835 m = rep
836 if _, ok = m["bar"]; !ok {
837 break
838 }
839 return "findWorldWithMultipleKeysByBar", nil
840 }
841 return "", fmt.Errorf("%w for WorldWithMultipleKeys", ErrTypeNotFound)
842 }
843
View as plain text