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  }