federation.go

Documentation: github.com/99designs/gqlgen/plugin/federation/testdata/federation2/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  )
    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  		default:
    69  			return false
    70  		}
    71  	}
    72  
    73  	resolveEntity := func(ctx context.Context, typeName string, rep map[string]interface{}, idx []int, i int) (err error) {
    74  		// we need to do our own panic handling, because we may be called in a
    75  		// goroutine, where the usual panic handling can't catch us
    76  		defer func() {
    77  			if r := recover(); r != nil {
    78  				err = ec.Recover(ctx, r)
    79  			}
    80  		}()
    81  
    82  		switch typeName {
    83  		case "ExternalExtension":
    84  			resolverName, err := entityResolverNameForExternalExtension(ctx, rep)
    85  			if err != nil {
    86  				return fmt.Errorf(`finding resolver for Entity "ExternalExtension": %w`, err)
    87  			}
    88  			switch resolverName {
    89  
    90  			case "findExternalExtensionByUpc":
    91  				id0, err := ec.unmarshalNString2string(ctx, rep["upc"])
    92  				if err != nil {
    93  					return fmt.Errorf(`unmarshalling param 0 for findExternalExtensionByUpc(): %w`, err)
    94  				}
    95  				entity, err := ec.resolvers.Entity().FindExternalExtensionByUpc(ctx, id0)
    96  				if err != nil {
    97  					return fmt.Errorf(`resolving Entity "ExternalExtension": %w`, err)
    98  				}
    99  
   100  				list[idx[i]] = entity
   101  				return nil
   102  			}
   103  
   104  		}
   105  		return fmt.Errorf("%w: %s", ErrUnknownType, typeName)
   106  	}
   107  
   108  	resolveManyEntities := func(ctx context.Context, typeName string, reps []map[string]interface{}, idx []int) (err error) {
   109  		// we need to do our own panic handling, because we may be called in a
   110  		// goroutine, where the usual panic handling can't catch us
   111  		defer func() {
   112  			if r := recover(); r != nil {
   113  				err = ec.Recover(ctx, r)
   114  			}
   115  		}()
   116  
   117  		switch typeName {
   118  
   119  		default:
   120  			return errors.New("unknown type: " + typeName)
   121  		}
   122  	}
   123  
   124  	resolveEntityGroup := func(typeName string, reps []map[string]interface{}, idx []int) {
   125  		if isMulti(typeName) {
   126  			err := resolveManyEntities(ctx, typeName, reps, idx)
   127  			if err != nil {
   128  				ec.Error(ctx, err)
   129  			}
   130  		} else {
   131  			// if there are multiple entities to resolve, parallelize (similar to
   132  			// graphql.FieldSet.Dispatch)
   133  			var e sync.WaitGroup
   134  			e.Add(len(reps))
   135  			for i, rep := range reps {
   136  				i, rep := i, rep
   137  				go func(i int, rep map[string]interface{}) {
   138  					err := resolveEntity(ctx, typeName, rep, idx, i)
   139  					if err != nil {
   140  						ec.Error(ctx, err)
   141  					}
   142  					e.Done()
   143  				}(i, rep)
   144  			}
   145  			e.Wait()
   146  		}
   147  	}
   148  	buildRepresentationGroups(representations)
   149  
   150  	switch len(repsMap) {
   151  	case 0:
   152  		return list
   153  	case 1:
   154  		for typeName, reps := range repsMap {
   155  			resolveEntityGroup(typeName, reps.r, reps.i)
   156  		}
   157  		return list
   158  	default:
   159  		var g sync.WaitGroup
   160  		g.Add(len(repsMap))
   161  		for typeName, reps := range repsMap {
   162  			go func(typeName string, reps []map[string]interface{}, idx []int) {
   163  				resolveEntityGroup(typeName, reps, idx)
   164  				g.Done()
   165  			}(typeName, reps.r, reps.i)
   166  		}
   167  		g.Wait()
   168  		return list
   169  	}
   170  }
   171  
   172  func entityResolverNameForExternalExtension(ctx context.Context, rep map[string]interface{}) (string, error) {
   173  	for {
   174  		var (
   175  			m   map[string]interface{}
   176  			val interface{}
   177  			ok  bool
   178  		)
   179  		_ = val
   180  		m = rep
   181  		if _, ok = m["upc"]; !ok {
   182  			break
   183  		}
   184  		return "findExternalExtensionByUpc", nil
   185  	}
   186  	return "", fmt.Errorf("%w for ExternalExtension", ErrTypeNotFound)
   187  }
   188
View as plain text