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