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 }}