...

Source file src/github.com/99designs/gqlgen/plugin/federation/testdata/entityresolver/generated/federation.go

Documentation: github.com/99designs/gqlgen/plugin/federation/testdata/entityresolver/generated

     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/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  	// We group entities by typename so that we can parallelize their resolution.
    49  	// This is particularly helpful when there are entity groups in multi mode.
    50  	buildRepresentationGroups := func(reps []map[string]interface{}) {
    51  		for i, rep := range reps {
    52  			typeName, ok := rep["__typename"].(string)
    53  			if !ok {
    54  				// If there is no __typename, we just skip the representation;
    55  				// we just won't be resolving these unknown types.
    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  		// we need to do our own panic handling, because we may be called in a
    86  		// goroutine, where the usual panic handling can't catch us
    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  		// we need to do our own panic handling, because we may be called in a
   321  		// goroutine, where the usual panic handling can't catch us
   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  			// if there are multiple entities to resolve, parallelize (similar to
   534  			// graphql.FieldSet.Dispatch)
   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