github.com/niko0xdev/gqlgen@v0.17.55-0.20240120102243-2ecff98c3e37/codegen/field.gotpl (about)

     1  {{- range $object := .Objects }}{{- range $field := $object.Fields }}
     2  
     3  func (ec *executionContext) _{{$object.Name}}_{{$field.Name}}(ctx context.Context, field graphql.CollectedField{{ if not $object.Root }}, obj {{$object.Reference | ref}}{{end}}) (ret {{ if $object.Stream }}func(ctx context.Context){{ end }}graphql.Marshaler) {
     4  	{{- $null := "graphql.Null" }}
     5  	{{- if $object.Stream }}
     6  		{{- $null = "nil" }}
     7  	{{- end }}
     8  	fc, err := ec.{{ $field.FieldContextFunc }}(ctx, field)
     9  	if err != nil {
    10  		return {{ $null }}
    11  	}
    12  	ctx = graphql.WithFieldContext(ctx, fc)
    13  	defer func () {
    14  		if r := recover(); r != nil {
    15  			ec.Error(ctx, ec.Recover(ctx, r))
    16  			ret = {{ $null }}
    17  		}
    18  	}()
    19  	{{- if $field.TypeReference.IsRoot }}
    20  		{{- if $field.TypeReference.IsPtr }}
    21  			res := &{{ $field.TypeReference.Elem.GO | ref }}{}
    22  		{{- else }}
    23  			res := {{ $field.TypeReference.GO | ref }}{}
    24  		{{- end }} 
    25  		fc.Result = res
    26  		return ec.{{ $field.TypeReference.MarshalFunc }}(ctx, field.Selections, res)
    27  	{{- else}}
    28  			resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
    29  				{{ template "field" $field }}
    30  			})
    31  			if err != nil {
    32  				ec.Error(ctx, err)
    33  				return {{ $null }}
    34  			}
    35  		if resTmp == nil {
    36  			{{- if $field.TypeReference.GQL.NonNull }}
    37  				if !graphql.HasFieldError(ctx, fc) {
    38  					ec.Errorf(ctx, "must not be null")
    39  				}
    40  			{{- end }}
    41  			return {{ $null }}
    42  		}
    43  		{{- if $object.Stream }}
    44  			return func(ctx context.Context) graphql.Marshaler {
    45  				select {
    46  				case res, ok := <-resTmp.(<-chan {{$field.TypeReference.GO | ref}}):
    47  					if !ok {
    48  						return nil
    49  					}
    50  					return graphql.WriterFunc(func(w io.Writer) {
    51  						w.Write([]byte{'{'})
    52  						graphql.MarshalString(field.Alias).MarshalGQL(w)
    53  						w.Write([]byte{':'})
    54  						ec.{{ $field.TypeReference.MarshalFunc }}(ctx, field.Selections, res).MarshalGQL(w)
    55  						w.Write([]byte{'}'})
    56  					})
    57  				case <-ctx.Done():
    58  					return nil
    59  				}
    60  			}
    61  		{{- else }}
    62  			res := resTmp.({{$field.TypeReference.GO | ref}})
    63  			fc.Result = res
    64  			return ec.{{ $field.TypeReference.MarshalFunc }}(ctx, field.Selections, res)
    65  		{{- end }}
    66  	{{- end }}
    67  }
    68  
    69  func (ec *executionContext) {{ $field.FieldContextFunc }}(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
    70  	fc = &graphql.FieldContext{
    71  		Object: {{quote $field.Object.Name}},
    72  		Field: field,
    73  		IsMethod: {{or $field.IsMethod $field.IsResolver}},
    74  		IsResolver: {{ $field.IsResolver }},
    75  		Child: func (ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
    76  			{{- if not $field.TypeReference.Definition.Fields }}
    77  				return nil, errors.New("field of type {{ $field.TypeReference.Definition.Name }} does not have child fields")
    78  			{{- else if ne $field.TypeReference.Definition.Kind "OBJECT" }}
    79  				return nil, errors.New("FieldContext.Child cannot be called on type {{ $field.TypeReference.Definition.Kind }}")
    80  			{{- else }}
    81  				switch field.Name {
    82  					{{- range $f := $field.TypeReference.Definition.Fields }}
    83  						case "{{ $f.Name }}":
    84  							return ec.{{ $field.ChildFieldContextFunc $f.Name }}(ctx, field)
    85  					{{- end }}
    86  				}
    87  				return nil, fmt.Errorf("no field named %q was found under type {{ $field.TypeReference.Definition.Name }}", field.Name)
    88  			{{- end }}
    89  		},
    90  	}
    91  	{{- if $field.Args }}
    92  		defer func () {
    93  			if r := recover(); r != nil {
    94  				err = ec.Recover(ctx, r)
    95  				ec.Error(ctx, err)
    96  			}
    97  		}()
    98  		ctx = graphql.WithFieldContext(ctx, fc)
    99  		if fc.Args, err = ec.{{ $field.ArgsFunc }}(ctx, field.ArgumentMap(ec.Variables)); err != nil {
   100  			ec.Error(ctx, err)
   101  			return fc, err
   102  		}
   103  	{{- end }}
   104  	return fc, nil
   105  }
   106  
   107  {{- end }}{{- end}}
   108  
   109  {{ define "field" }}
   110  	{{- if .HasDirectives -}}
   111  		directive0 := func(rctx context.Context) (interface{}, error) {
   112  			ctx = rctx  // use context from middleware stack in children
   113  			{{ template "fieldDefinition" . }}
   114  		}
   115  		{{ template "implDirectives" . }}
   116  		tmp, err := directive{{.ImplDirectives|len}}(rctx)
   117  		if err != nil {
   118  			return nil, graphql.ErrorOnPath(ctx, err)
   119  		}
   120  		if tmp == nil {
   121  		    return nil, nil
   122  		}
   123  		if data, ok := tmp.({{if .Stream}}<-chan {{end}}{{ .TypeReference.GO | ref }}) ; ok {
   124  			return data, nil
   125  		}
   126  		return nil, fmt.Errorf(`unexpected type %T from directive, should be {{if .Stream}}<-chan {{end}}{{ .TypeReference.GO }}`, tmp)
   127  	{{- else -}}
   128  		ctx = rctx  // use context from middleware stack in children
   129  		{{ template "fieldDefinition" . }}
   130  	{{- end -}}
   131  {{ end }}
   132  
   133  {{ define "fieldDefinition" }}
   134  	{{- if .IsResolver -}}
   135  		return ec.resolvers.{{ .ShortInvocation }}
   136  	{{- else if .IsMap -}}
   137  		switch v := {{.GoReceiverName}}[{{.Name|quote}}].(type) {
   138  		case {{if .Stream}}<-chan {{end}}{{.TypeReference.GO | ref}}:
   139  			return v, nil
   140  		case {{if .Stream}}<-chan {{end}}{{.TypeReference.Elem.GO | ref}}:
   141  			return &v, nil
   142  		case nil:
   143  			return ({{.TypeReference.GO | ref}})(nil), nil
   144  		default:
   145  			return nil, fmt.Errorf("unexpected type %T for field %s", v, {{ .Name | quote}})
   146  		}
   147  	{{- else if .IsMethod -}}
   148  		{{- if .VOkFunc -}}
   149  			v, ok := {{.GoReceiverName}}.{{.GoFieldName}}({{ .CallArgs }})
   150  			if !ok {
   151  				return nil, nil
   152  			}
   153  			return v, nil
   154  		{{- else if .NoErr -}}
   155  			return {{.GoReceiverName}}.{{.GoFieldName}}({{ .CallArgs }}), nil
   156  		{{- else -}}
   157  			return {{.GoReceiverName}}.{{.GoFieldName}}({{ .CallArgs }})
   158  		{{- end -}}
   159  	{{- else if .IsVariable -}}
   160  		return {{.GoReceiverName}}.{{.GoFieldName}}, nil
   161  	{{- end }}
   162  {{- end }}