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