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