github.com/kerryoscer/gqlgen@v0.17.29/codegen/generated!.gotpl (about) 1 {{ reserveImport "context" }} 2 {{ reserveImport "fmt" }} 3 {{ reserveImport "io" }} 4 {{ reserveImport "strconv" }} 5 {{ reserveImport "time" }} 6 {{ reserveImport "sync" }} 7 {{ reserveImport "sync/atomic" }} 8 {{ reserveImport "errors" }} 9 {{ reserveImport "bytes" }} 10 {{ reserveImport "embed" }} 11 12 {{ reserveImport "github.com/vektah/gqlparser/v2" "gqlparser" }} 13 {{ reserveImport "github.com/vektah/gqlparser/v2/ast" }} 14 {{ reserveImport "github.com/kerryoscer/gqlgen/graphql" }} 15 {{ reserveImport "github.com/kerryoscer/gqlgen/graphql/introspection" }} 16 17 18 {{ if eq .Config.Exec.Layout "single-file" }} 19 // NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface. 20 func NewExecutableSchema(cfg Config) graphql.ExecutableSchema { 21 return &executableSchema{ 22 resolvers: cfg.Resolvers, 23 directives: cfg.Directives, 24 complexity: cfg.Complexity, 25 } 26 } 27 28 type Config struct { 29 Resolvers ResolverRoot 30 Directives DirectiveRoot 31 Complexity ComplexityRoot 32 } 33 34 type ResolverRoot interface { 35 {{- range $object := .Objects -}} 36 {{ if $object.HasResolvers -}} 37 {{ucFirst $object.Name}}() {{ucFirst $object.Name}}Resolver 38 {{ end }} 39 {{- end }} 40 {{- range $object := .Inputs -}} 41 {{ if $object.HasResolvers -}} 42 {{ucFirst $object.Name}}() {{ucFirst $object.Name}}Resolver 43 {{ end }} 44 {{- end }} 45 } 46 47 type DirectiveRoot struct { 48 {{ range $directive := .Directives }} 49 {{- $directive.Declaration }} 50 {{ end }} 51 } 52 53 type ComplexityRoot struct { 54 {{- if not .Config.OmitComplexity }} 55 {{ range $object := .Objects }} 56 {{ if not $object.IsReserved -}} 57 {{ ucFirst $object.Name }} struct { 58 {{ range $_, $fields := $object.UniqueFields }} 59 {{- $field := index $fields 0 -}} 60 {{ if not $field.IsReserved -}} 61 {{ $field.GoFieldName }} {{ $field.ComplexitySignature }} 62 {{ end }} 63 {{- end }} 64 } 65 {{- end }} 66 {{ end }} 67 {{- end }} 68 } 69 {{ end }} 70 71 {{ range $object := .Objects -}} 72 {{ if $object.HasResolvers }} 73 type {{ucFirst $object.Name}}Resolver interface { 74 {{ range $field := $object.Fields -}} 75 {{- if $field.IsResolver }} 76 {{- $field.GoFieldName}}{{ $field.ShortResolverDeclaration }} 77 {{- end }} 78 {{ end }} 79 } 80 {{- end }} 81 {{- end }} 82 83 {{ range $object := .Inputs -}} 84 {{ if $object.HasResolvers }} 85 type {{$object.Name}}Resolver interface { 86 {{ range $field := $object.Fields -}} 87 {{- if $field.IsResolver }} 88 {{- $field.GoFieldName}}{{ $field.ShortResolverDeclaration }} 89 {{- end }} 90 {{ end }} 91 } 92 {{- end }} 93 {{- end }} 94 95 {{ if eq .Config.Exec.Layout "single-file" }} 96 type executableSchema struct { 97 resolvers ResolverRoot 98 directives DirectiveRoot 99 complexity ComplexityRoot 100 } 101 102 func (e *executableSchema) Schema() *ast.Schema { 103 return parsedSchema 104 } 105 106 func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) { 107 ec := executionContext{nil, e} 108 _ = ec 109 {{ if not .Config.OmitComplexity -}} 110 switch typeName + "." + field { 111 {{ range $object := .Objects }} 112 {{ if not $object.IsReserved }} 113 {{ range $_, $fields := $object.UniqueFields }} 114 {{- $len := len $fields }} 115 {{- range $i, $field := $fields }} 116 {{- $last := eq (add $i 1) $len }} 117 {{- if not $field.IsReserved }} 118 {{- if eq $i 0 }}case {{ end }}"{{$object.Name}}.{{$field.Name}}"{{ if not $last }},{{ else }}: 119 if e.complexity.{{ucFirst $object.Name}}.{{$field.GoFieldName}} == nil { 120 break 121 } 122 {{ if $field.Args }} 123 args, err := ec.{{ $field.ArgsFunc }}(context.TODO(),rawArgs) 124 if err != nil { 125 return 0, false 126 } 127 {{ end }} 128 return e.complexity.{{ucFirst $object.Name}}.{{$field.GoFieldName}}(childComplexity{{if $field.Args}}, {{$field.ComplexityArgs}} {{ end }}), true 129 {{ end }} 130 {{- end }} 131 {{- end }} 132 {{ end }} 133 {{ end }} 134 {{ end }} 135 } 136 {{- end }} 137 return 0, false 138 } 139 140 func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { 141 rc := graphql.GetOperationContext(ctx) 142 ec := executionContext{rc, e} 143 inputUnmarshalMap := graphql.BuildUnmarshalerMap( 144 {{- range $input := .Inputs -}} 145 {{ if not $input.HasUnmarshal }} 146 ec.unmarshalInput{{ $input.Name }}, 147 {{- end }} 148 {{- end }} 149 ) 150 first := true 151 152 switch rc.Operation.Operation { 153 {{- if .QueryRoot }} case ast.Query: 154 return func(ctx context.Context) *graphql.Response { 155 if !first { return nil } 156 first = false 157 ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap) 158 {{ if .Directives.LocationDirectives "QUERY" -}} 159 data := ec._queryMiddleware(ctx, rc.Operation, func(ctx context.Context) (interface{}, error){ 160 return ec._{{.QueryRoot.Name}}(ctx, rc.Operation.SelectionSet), nil 161 }) 162 {{- else -}} 163 data := ec._{{.QueryRoot.Name}}(ctx, rc.Operation.SelectionSet) 164 {{- end }} 165 var buf bytes.Buffer 166 data.MarshalGQL(&buf) 167 168 return &graphql.Response{ 169 Data: buf.Bytes(), 170 } 171 } 172 {{ end }} 173 174 {{- if .MutationRoot }} case ast.Mutation: 175 return func(ctx context.Context) *graphql.Response { 176 if !first { return nil } 177 first = false 178 ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap) 179 {{ if .Directives.LocationDirectives "MUTATION" -}} 180 data := ec._mutationMiddleware(ctx, rc.Operation, func(ctx context.Context) (interface{}, error){ 181 return ec._{{.MutationRoot.Name}}(ctx, rc.Operation.SelectionSet), nil 182 }) 183 {{- else -}} 184 data := ec._{{.MutationRoot.Name}}(ctx, rc.Operation.SelectionSet) 185 {{- end }} 186 var buf bytes.Buffer 187 data.MarshalGQL(&buf) 188 189 return &graphql.Response{ 190 Data: buf.Bytes(), 191 } 192 } 193 {{ end }} 194 195 {{- if .SubscriptionRoot }} case ast.Subscription: 196 {{ if .Directives.LocationDirectives "SUBSCRIPTION" -}} 197 next := ec._subscriptionMiddleware(ctx, rc.Operation, func(ctx context.Context) (interface{}, error){ 198 return ec._{{.SubscriptionRoot.Name}}(ctx, rc.Operation.SelectionSet),nil 199 }) 200 {{- else -}} 201 next := ec._{{.SubscriptionRoot.Name}}(ctx, rc.Operation.SelectionSet) 202 {{- end }} 203 204 var buf bytes.Buffer 205 return func(ctx context.Context) *graphql.Response { 206 buf.Reset() 207 data := next(ctx) 208 209 if data == nil { 210 return nil 211 } 212 data.MarshalGQL(&buf) 213 214 return &graphql.Response{ 215 Data: buf.Bytes(), 216 } 217 } 218 {{ end }} 219 default: 220 return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation")) 221 } 222 } 223 224 type executionContext struct { 225 *graphql.OperationContext 226 *executableSchema 227 } 228 229 func (ec *executionContext) introspectSchema() (*introspection.Schema, error) { 230 if ec.DisableIntrospection { 231 return nil, errors.New("introspection disabled") 232 } 233 return introspection.WrapSchema(parsedSchema), nil 234 } 235 236 func (ec *executionContext) introspectType(name string) (*introspection.Type, error) { 237 if ec.DisableIntrospection { 238 return nil, errors.New("introspection disabled") 239 } 240 return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil 241 } 242 243 {{if .HasEmbeddableSources }} 244 //go:embed{{- range $source := .AugmentedSources }}{{if $source.Embeddable}} {{$source.RelativePath|quote}}{{end}}{{- end }} 245 var sourcesFS embed.FS 246 247 func sourceData(filename string) string { 248 data, err := sourcesFS.ReadFile(filename) 249 if err != nil { 250 panic(fmt.Sprintf("codegen problem: %s not available", filename)) 251 } 252 return string(data) 253 } 254 {{- end }} 255 256 var sources = []*ast.Source{ 257 {{- range $source := .AugmentedSources }} 258 {Name: {{$source.RelativePath|quote}}, Input: {{if (not $source.Embeddable)}}{{$source.Source|rawQuote}}{{else}}sourceData({{$source.RelativePath|quote}}){{end}}, BuiltIn: {{$source.BuiltIn}}}, 259 {{- end }} 260 } 261 var parsedSchema = gqlparser.MustLoadSchema(sources...) 262 {{ end }}