github.com/kerryoscer/gqlgen@v0.17.29/plugin/federation/testdata/entityresolver/generated/federation.go (about) 1 // Code generated by github.com/99designs/gqlgen, DO NOT EDIT. 2 3 package generated 4 5 import ( 6 "context" 7 "errors" 8 "fmt" 9 "strings" 10 "sync" 11 12 "github.com/kerryoscer/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 // We group entities by typename so that we can parallelize their resolution. 48 // This is particularly helpful when there are entity groups in multi mode. 49 buildRepresentationGroups := func(reps []map[string]interface{}) { 50 for i, rep := range reps { 51 typeName, ok := rep["__typename"].(string) 52 if !ok { 53 // If there is no __typename, we just skip the representation; 54 // we just won't be resolving these unknown types. 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 // we need to do our own panic handling, because we may be called in a 85 // goroutine, where the usual panic handling can't catch us 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 entity.Diameter, err = ec.unmarshalNInt2int(ctx, rep["diameter"]) 175 if err != nil { 176 return err 177 } 178 entity.Density, err = ec.unmarshalNInt2int(ctx, rep["density"]) 179 if err != nil { 180 return err 181 } 182 list[idx[i]] = entity 183 return nil 184 } 185 case "PlanetRequires": 186 resolverName, err := entityResolverNameForPlanetRequires(ctx, rep) 187 if err != nil { 188 return fmt.Errorf(`finding resolver for Entity "PlanetRequires": %w`, err) 189 } 190 switch resolverName { 191 192 case "findPlanetRequiresByName": 193 id0, err := ec.unmarshalNString2string(ctx, rep["name"]) 194 if err != nil { 195 return fmt.Errorf(`unmarshalling param 0 for findPlanetRequiresByName(): %w`, err) 196 } 197 entity, err := ec.resolvers.Entity().FindPlanetRequiresByName(ctx, id0) 198 if err != nil { 199 return fmt.Errorf(`resolving Entity "PlanetRequires": %w`, err) 200 } 201 202 entity.Diameter, err = ec.unmarshalNInt2int(ctx, rep["diameter"]) 203 if err != nil { 204 return err 205 } 206 list[idx[i]] = entity 207 return nil 208 } 209 case "PlanetRequiresNested": 210 resolverName, err := entityResolverNameForPlanetRequiresNested(ctx, rep) 211 if err != nil { 212 return fmt.Errorf(`finding resolver for Entity "PlanetRequiresNested": %w`, err) 213 } 214 switch resolverName { 215 216 case "findPlanetRequiresNestedByName": 217 id0, err := ec.unmarshalNString2string(ctx, rep["name"]) 218 if err != nil { 219 return fmt.Errorf(`unmarshalling param 0 for findPlanetRequiresNestedByName(): %w`, err) 220 } 221 entity, err := ec.resolvers.Entity().FindPlanetRequiresNestedByName(ctx, id0) 222 if err != nil { 223 return fmt.Errorf(`resolving Entity "PlanetRequiresNested": %w`, err) 224 } 225 226 entity.World.Foo, err = ec.unmarshalNString2string(ctx, rep["world"].(map[string]interface{})["foo"]) 227 if err != nil { 228 return err 229 } 230 list[idx[i]] = entity 231 return nil 232 } 233 case "World": 234 resolverName, err := entityResolverNameForWorld(ctx, rep) 235 if err != nil { 236 return fmt.Errorf(`finding resolver for Entity "World": %w`, err) 237 } 238 switch resolverName { 239 240 case "findWorldByHelloNameAndFoo": 241 id0, err := ec.unmarshalNString2string(ctx, rep["hello"].(map[string]interface{})["name"]) 242 if err != nil { 243 return fmt.Errorf(`unmarshalling param 0 for findWorldByHelloNameAndFoo(): %w`, err) 244 } 245 id1, err := ec.unmarshalNString2string(ctx, rep["foo"]) 246 if err != nil { 247 return fmt.Errorf(`unmarshalling param 1 for findWorldByHelloNameAndFoo(): %w`, err) 248 } 249 entity, err := ec.resolvers.Entity().FindWorldByHelloNameAndFoo(ctx, id0, id1) 250 if err != nil { 251 return fmt.Errorf(`resolving Entity "World": %w`, err) 252 } 253 254 list[idx[i]] = entity 255 return nil 256 } 257 case "WorldName": 258 resolverName, err := entityResolverNameForWorldName(ctx, rep) 259 if err != nil { 260 return fmt.Errorf(`finding resolver for Entity "WorldName": %w`, err) 261 } 262 switch resolverName { 263 264 case "findWorldNameByName": 265 id0, err := ec.unmarshalNString2string(ctx, rep["name"]) 266 if err != nil { 267 return fmt.Errorf(`unmarshalling param 0 for findWorldNameByName(): %w`, err) 268 } 269 entity, err := ec.resolvers.Entity().FindWorldNameByName(ctx, id0) 270 if err != nil { 271 return fmt.Errorf(`resolving Entity "WorldName": %w`, err) 272 } 273 274 list[idx[i]] = entity 275 return nil 276 } 277 case "WorldWithMultipleKeys": 278 resolverName, err := entityResolverNameForWorldWithMultipleKeys(ctx, rep) 279 if err != nil { 280 return fmt.Errorf(`finding resolver for Entity "WorldWithMultipleKeys": %w`, err) 281 } 282 switch resolverName { 283 284 case "findWorldWithMultipleKeysByHelloNameAndFoo": 285 id0, err := ec.unmarshalNString2string(ctx, rep["hello"].(map[string]interface{})["name"]) 286 if err != nil { 287 return fmt.Errorf(`unmarshalling param 0 for findWorldWithMultipleKeysByHelloNameAndFoo(): %w`, err) 288 } 289 id1, err := ec.unmarshalNString2string(ctx, rep["foo"]) 290 if err != nil { 291 return fmt.Errorf(`unmarshalling param 1 for findWorldWithMultipleKeysByHelloNameAndFoo(): %w`, err) 292 } 293 entity, err := ec.resolvers.Entity().FindWorldWithMultipleKeysByHelloNameAndFoo(ctx, id0, id1) 294 if err != nil { 295 return fmt.Errorf(`resolving Entity "WorldWithMultipleKeys": %w`, err) 296 } 297 298 list[idx[i]] = entity 299 return nil 300 case "findWorldWithMultipleKeysByBar": 301 id0, err := ec.unmarshalNInt2int(ctx, rep["bar"]) 302 if err != nil { 303 return fmt.Errorf(`unmarshalling param 0 for findWorldWithMultipleKeysByBar(): %w`, err) 304 } 305 entity, err := ec.resolvers.Entity().FindWorldWithMultipleKeysByBar(ctx, id0) 306 if err != nil { 307 return fmt.Errorf(`resolving Entity "WorldWithMultipleKeys": %w`, err) 308 } 309 310 list[idx[i]] = entity 311 return nil 312 } 313 314 } 315 return fmt.Errorf("%w: %s", ErrUnknownType, typeName) 316 } 317 318 resolveManyEntities := func(ctx context.Context, typeName string, reps []map[string]interface{}, idx []int) (err error) { 319 // we need to do our own panic handling, because we may be called in a 320 // goroutine, where the usual panic handling can't catch us 321 defer func() { 322 if r := recover(); r != nil { 323 err = ec.Recover(ctx, r) 324 } 325 }() 326 327 switch typeName { 328 329 case "MultiHello": 330 _reps := make([]*MultiHelloByNamesInput, len(reps)) 331 332 for i, rep := range reps { 333 id0, err := ec.unmarshalNString2string(ctx, rep["name"]) 334 if err != nil { 335 return errors.New(fmt.Sprintf("Field %s undefined in schema.", "name")) 336 } 337 338 _reps[i] = &MultiHelloByNamesInput{ 339 Name: id0, 340 } 341 } 342 343 entities, err := ec.resolvers.Entity().FindManyMultiHelloByNames(ctx, _reps) 344 if err != nil { 345 return err 346 } 347 348 for i, entity := range entities { 349 list[idx[i]] = entity 350 } 351 return nil 352 353 case "MultiHelloMultipleRequires": 354 _reps := make([]*MultiHelloMultipleRequiresByNamesInput, len(reps)) 355 356 for i, rep := range reps { 357 id0, err := ec.unmarshalNString2string(ctx, rep["name"]) 358 if err != nil { 359 return errors.New(fmt.Sprintf("Field %s undefined in schema.", "name")) 360 } 361 362 _reps[i] = &MultiHelloMultipleRequiresByNamesInput{ 363 Name: id0, 364 } 365 } 366 367 entities, err := ec.resolvers.Entity().FindManyMultiHelloMultipleRequiresByNames(ctx, _reps) 368 if err != nil { 369 return err 370 } 371 372 for i, entity := range entities { 373 entity.Key1, err = ec.unmarshalNString2string(ctx, reps[i]["key1"]) 374 if err != nil { 375 return err 376 } 377 entity.Key2, err = ec.unmarshalNString2string(ctx, reps[i]["key2"]) 378 if err != nil { 379 return err 380 } 381 list[idx[i]] = entity 382 } 383 return nil 384 385 case "MultiHelloRequires": 386 _reps := make([]*MultiHelloRequiresByNamesInput, len(reps)) 387 388 for i, rep := range reps { 389 id0, err := ec.unmarshalNString2string(ctx, rep["name"]) 390 if err != nil { 391 return errors.New(fmt.Sprintf("Field %s undefined in schema.", "name")) 392 } 393 394 _reps[i] = &MultiHelloRequiresByNamesInput{ 395 Name: id0, 396 } 397 } 398 399 entities, err := ec.resolvers.Entity().FindManyMultiHelloRequiresByNames(ctx, _reps) 400 if err != nil { 401 return err 402 } 403 404 for i, entity := range entities { 405 entity.Key1, err = ec.unmarshalNString2string(ctx, reps[i]["key1"]) 406 if err != nil { 407 return err 408 } 409 list[idx[i]] = entity 410 } 411 return nil 412 413 case "MultiHelloWithError": 414 _reps := make([]*MultiHelloWithErrorByNamesInput, len(reps)) 415 416 for i, rep := range reps { 417 id0, err := ec.unmarshalNString2string(ctx, rep["name"]) 418 if err != nil { 419 return errors.New(fmt.Sprintf("Field %s undefined in schema.", "name")) 420 } 421 422 _reps[i] = &MultiHelloWithErrorByNamesInput{ 423 Name: id0, 424 } 425 } 426 427 entities, err := ec.resolvers.Entity().FindManyMultiHelloWithErrorByNames(ctx, _reps) 428 if err != nil { 429 return err 430 } 431 432 for i, entity := range entities { 433 list[idx[i]] = entity 434 } 435 return nil 436 437 case "MultiPlanetRequiresNested": 438 _reps := make([]*MultiPlanetRequiresNestedByNamesInput, len(reps)) 439 440 for i, rep := range reps { 441 id0, err := ec.unmarshalNString2string(ctx, rep["name"]) 442 if err != nil { 443 return errors.New(fmt.Sprintf("Field %s undefined in schema.", "name")) 444 } 445 446 _reps[i] = &MultiPlanetRequiresNestedByNamesInput{ 447 Name: id0, 448 } 449 } 450 451 entities, err := ec.resolvers.Entity().FindManyMultiPlanetRequiresNestedByNames(ctx, _reps) 452 if err != nil { 453 return err 454 } 455 456 for i, entity := range entities { 457 entity.World.Foo, err = ec.unmarshalNString2string(ctx, reps[i]["world"].(map[string]interface{})["foo"]) 458 if err != nil { 459 return err 460 } 461 list[idx[i]] = entity 462 } 463 return nil 464 465 default: 466 return errors.New("unknown type: " + typeName) 467 } 468 } 469 470 resolveEntityGroup := func(typeName string, reps []map[string]interface{}, idx []int) { 471 if isMulti(typeName) { 472 err := resolveManyEntities(ctx, typeName, reps, idx) 473 if err != nil { 474 ec.Error(ctx, err) 475 } 476 } else { 477 // if there are multiple entities to resolve, parallelize (similar to 478 // graphql.FieldSet.Dispatch) 479 var e sync.WaitGroup 480 e.Add(len(reps)) 481 for i, rep := range reps { 482 i, rep := i, rep 483 go func(i int, rep map[string]interface{}) { 484 err := resolveEntity(ctx, typeName, rep, idx, i) 485 if err != nil { 486 ec.Error(ctx, err) 487 } 488 e.Done() 489 }(i, rep) 490 } 491 e.Wait() 492 } 493 } 494 buildRepresentationGroups(representations) 495 496 switch len(repsMap) { 497 case 0: 498 return list 499 case 1: 500 for typeName, reps := range repsMap { 501 resolveEntityGroup(typeName, reps.r, reps.i) 502 } 503 return list 504 default: 505 var g sync.WaitGroup 506 g.Add(len(repsMap)) 507 for typeName, reps := range repsMap { 508 go func(typeName string, reps []map[string]interface{}, idx []int) { 509 resolveEntityGroup(typeName, reps, idx) 510 g.Done() 511 }(typeName, reps.r, reps.i) 512 } 513 g.Wait() 514 return list 515 } 516 } 517 518 func entityResolverNameForHello(ctx context.Context, rep map[string]interface{}) (string, error) { 519 for { 520 var ( 521 m map[string]interface{} 522 val interface{} 523 ok bool 524 ) 525 _ = val 526 m = rep 527 if _, ok = m["name"]; !ok { 528 break 529 } 530 return "findHelloByName", nil 531 } 532 return "", fmt.Errorf("%w for Hello", ErrTypeNotFound) 533 } 534 535 func entityResolverNameForHelloMultiSingleKeys(ctx context.Context, rep map[string]interface{}) (string, error) { 536 for { 537 var ( 538 m map[string]interface{} 539 val interface{} 540 ok bool 541 ) 542 _ = val 543 m = rep 544 if _, ok = m["key1"]; !ok { 545 break 546 } 547 m = rep 548 if _, ok = m["key2"]; !ok { 549 break 550 } 551 return "findHelloMultiSingleKeysByKey1AndKey2", nil 552 } 553 return "", fmt.Errorf("%w for HelloMultiSingleKeys", ErrTypeNotFound) 554 } 555 556 func entityResolverNameForHelloWithErrors(ctx context.Context, rep map[string]interface{}) (string, error) { 557 for { 558 var ( 559 m map[string]interface{} 560 val interface{} 561 ok bool 562 ) 563 _ = val 564 m = rep 565 if _, ok = m["name"]; !ok { 566 break 567 } 568 return "findHelloWithErrorsByName", nil 569 } 570 return "", fmt.Errorf("%w for HelloWithErrors", ErrTypeNotFound) 571 } 572 573 func entityResolverNameForMultiHello(ctx context.Context, rep map[string]interface{}) (string, error) { 574 for { 575 var ( 576 m map[string]interface{} 577 val interface{} 578 ok bool 579 ) 580 _ = val 581 m = rep 582 if _, ok = m["name"]; !ok { 583 break 584 } 585 return "findManyMultiHelloByNames", nil 586 } 587 return "", fmt.Errorf("%w for MultiHello", ErrTypeNotFound) 588 } 589 590 func entityResolverNameForMultiHelloMultipleRequires(ctx context.Context, rep map[string]interface{}) (string, error) { 591 for { 592 var ( 593 m map[string]interface{} 594 val interface{} 595 ok bool 596 ) 597 _ = val 598 m = rep 599 if _, ok = m["name"]; !ok { 600 break 601 } 602 return "findManyMultiHelloMultipleRequiresByNames", nil 603 } 604 return "", fmt.Errorf("%w for MultiHelloMultipleRequires", ErrTypeNotFound) 605 } 606 607 func entityResolverNameForMultiHelloRequires(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 "findManyMultiHelloRequiresByNames", nil 620 } 621 return "", fmt.Errorf("%w for MultiHelloRequires", ErrTypeNotFound) 622 } 623 624 func entityResolverNameForMultiHelloWithError(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 "findManyMultiHelloWithErrorByNames", nil 637 } 638 return "", fmt.Errorf("%w for MultiHelloWithError", ErrTypeNotFound) 639 } 640 641 func entityResolverNameForMultiPlanetRequiresNested(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 "findManyMultiPlanetRequiresNestedByNames", nil 654 } 655 return "", fmt.Errorf("%w for MultiPlanetRequiresNested", ErrTypeNotFound) 656 } 657 658 func entityResolverNameForPlanetMultipleRequires(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 "findPlanetMultipleRequiresByName", nil 671 } 672 return "", fmt.Errorf("%w for PlanetMultipleRequires", ErrTypeNotFound) 673 } 674 675 func entityResolverNameForPlanetRequires(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 "findPlanetRequiresByName", nil 688 } 689 return "", fmt.Errorf("%w for PlanetRequires", ErrTypeNotFound) 690 } 691 692 func entityResolverNameForPlanetRequiresNested(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 "findPlanetRequiresNestedByName", nil 705 } 706 return "", fmt.Errorf("%w for PlanetRequiresNested", ErrTypeNotFound) 707 } 708 709 func entityResolverNameForWorld(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 val, ok = m["hello"]; !ok { 719 break 720 } 721 if m, ok = val.(map[string]interface{}); !ok { 722 break 723 } 724 if _, ok = m["name"]; !ok { 725 break 726 } 727 m = rep 728 if _, ok = m["foo"]; !ok { 729 break 730 } 731 return "findWorldByHelloNameAndFoo", nil 732 } 733 return "", fmt.Errorf("%w for World", ErrTypeNotFound) 734 } 735 736 func entityResolverNameForWorldName(ctx context.Context, rep map[string]interface{}) (string, error) { 737 for { 738 var ( 739 m map[string]interface{} 740 val interface{} 741 ok bool 742 ) 743 _ = val 744 m = rep 745 if _, ok = m["name"]; !ok { 746 break 747 } 748 return "findWorldNameByName", nil 749 } 750 return "", fmt.Errorf("%w for WorldName", ErrTypeNotFound) 751 } 752 753 func entityResolverNameForWorldWithMultipleKeys(ctx context.Context, rep map[string]interface{}) (string, error) { 754 for { 755 var ( 756 m map[string]interface{} 757 val interface{} 758 ok bool 759 ) 760 _ = val 761 m = rep 762 if val, ok = m["hello"]; !ok { 763 break 764 } 765 if m, ok = val.(map[string]interface{}); !ok { 766 break 767 } 768 if _, ok = m["name"]; !ok { 769 break 770 } 771 m = rep 772 if _, ok = m["foo"]; !ok { 773 break 774 } 775 return "findWorldWithMultipleKeysByHelloNameAndFoo", nil 776 } 777 for { 778 var ( 779 m map[string]interface{} 780 val interface{} 781 ok bool 782 ) 783 _ = val 784 m = rep 785 if _, ok = m["bar"]; !ok { 786 break 787 } 788 return "findWorldWithMultipleKeysByBar", nil 789 } 790 return "", fmt.Errorf("%w for WorldWithMultipleKeys", ErrTypeNotFound) 791 }