aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/github.com
diff options
context:
space:
mode:
authorMichael Muré <batolettre@gmail.com>2018-08-14 14:48:41 +0200
committerMichael Muré <batolettre@gmail.com>2018-08-14 14:48:41 +0200
commit5c568a362b73cf163b06bc7371982f9a7ceaaf29 (patch)
tree755b61f969913b5290f3d56f4cfba4070b8155bc /vendor/github.com
parentef0d8fa108fbdef24997a84a3c6ecbf21cbc0a9e (diff)
downloadgit-bug-5c568a362b73cf163b06bc7371982f9a7ceaaf29.tar.gz
gqlgen: add a small program to go:generate the code
Diffstat (limited to 'vendor/github.com')
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/build.go165
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/codegen.go153
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/config.go184
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/enum.go12
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/enum_build.go39
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/import.go29
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/import_build.go116
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/input_build.go86
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/interface.go13
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/interface_build.go94
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/model.go15
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/models_build.go91
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/object.go206
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/object_build.go144
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/templates/args.gotpl30
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/templates/data.go11
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/templates/field.gotpl80
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/templates/generated.gotpl175
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/templates/input.gotpl28
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/templates/interface.gotpl18
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/templates/models.gotpl65
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/templates/object.gotpl52
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/templates/templates.go139
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/type.go162
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/type_build.go112
-rw-r--r--vendor/github.com/vektah/gqlgen/codegen/util.go312
26 files changed, 2531 insertions, 0 deletions
diff --git a/vendor/github.com/vektah/gqlgen/codegen/build.go b/vendor/github.com/vektah/gqlgen/codegen/build.go
new file mode 100644
index 00000000..d56fc06f
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/build.go
@@ -0,0 +1,165 @@
+package codegen
+
+import (
+ "fmt"
+ "go/build"
+ "go/types"
+ "os"
+
+ "github.com/pkg/errors"
+ "golang.org/x/tools/go/loader"
+)
+
+type Build struct {
+ PackageName string
+ Objects Objects
+ Inputs Objects
+ Interfaces []*Interface
+ Imports []*Import
+ QueryRoot *Object
+ MutationRoot *Object
+ SubscriptionRoot *Object
+ SchemaRaw string
+}
+
+type ModelBuild struct {
+ PackageName string
+ Imports []*Import
+ Models []Model
+ Enums []Enum
+}
+
+// Create a list of models that need to be generated
+func (cfg *Config) models() (*ModelBuild, error) {
+ namedTypes := cfg.buildNamedTypes()
+
+ prog, err := cfg.loadProgram(namedTypes, true)
+ if err != nil {
+ return nil, errors.Wrap(err, "loading failed")
+ }
+ imports := buildImports(namedTypes, cfg.Model.Dir())
+
+ cfg.bindTypes(imports, namedTypes, cfg.Model.Dir(), prog)
+
+ models, err := cfg.buildModels(namedTypes, prog)
+ if err != nil {
+ return nil, err
+ }
+ return &ModelBuild{
+ PackageName: cfg.Model.Package,
+ Models: models,
+ Enums: cfg.buildEnums(namedTypes),
+ Imports: imports.finalize(),
+ }, nil
+}
+
+// bind a schema together with some code to generate a Build
+func (cfg *Config) bind() (*Build, error) {
+ namedTypes := cfg.buildNamedTypes()
+
+ prog, err := cfg.loadProgram(namedTypes, true)
+ if err != nil {
+ return nil, errors.Wrap(err, "loading failed")
+ }
+
+ imports := buildImports(namedTypes, cfg.Exec.Dir())
+ cfg.bindTypes(imports, namedTypes, cfg.Exec.Dir(), prog)
+
+ objects, err := cfg.buildObjects(namedTypes, prog, imports)
+ if err != nil {
+ return nil, err
+ }
+
+ inputs, err := cfg.buildInputs(namedTypes, prog, imports)
+ if err != nil {
+ return nil, err
+ }
+
+ b := &Build{
+ PackageName: cfg.Exec.Package,
+ Objects: objects,
+ Interfaces: cfg.buildInterfaces(namedTypes, prog),
+ Inputs: inputs,
+ Imports: imports.finalize(),
+ SchemaRaw: cfg.SchemaStr,
+ }
+
+ if qr, ok := cfg.schema.EntryPoints["query"]; ok {
+ b.QueryRoot = b.Objects.ByName(qr.TypeName())
+ }
+
+ if mr, ok := cfg.schema.EntryPoints["mutation"]; ok {
+ b.MutationRoot = b.Objects.ByName(mr.TypeName())
+ }
+
+ if sr, ok := cfg.schema.EntryPoints["subscription"]; ok {
+ b.SubscriptionRoot = b.Objects.ByName(sr.TypeName())
+ }
+
+ if b.QueryRoot == nil {
+ return b, fmt.Errorf("query entry point missing")
+ }
+
+ // Poke a few magic methods into query
+ q := b.Objects.ByName(b.QueryRoot.GQLType)
+ q.Fields = append(q.Fields, Field{
+ Type: &Type{namedTypes["__Schema"], []string{modPtr}, nil},
+ GQLName: "__schema",
+ NoErr: true,
+ GoMethodName: "ec.introspectSchema",
+ Object: q,
+ })
+ q.Fields = append(q.Fields, Field{
+ Type: &Type{namedTypes["__Type"], []string{modPtr}, nil},
+ GQLName: "__type",
+ NoErr: true,
+ GoMethodName: "ec.introspectType",
+ Args: []FieldArgument{
+ {GQLName: "name", Type: &Type{namedTypes["String"], []string{}, nil}, Object: &Object{}},
+ },
+ Object: q,
+ })
+
+ return b, nil
+}
+
+func (cfg *Config) validate() error {
+ namedTypes := cfg.buildNamedTypes()
+
+ _, err := cfg.loadProgram(namedTypes, false)
+ return err
+}
+
+func (cfg *Config) loadProgram(namedTypes NamedTypes, allowErrors bool) (*loader.Program, error) {
+ conf := loader.Config{}
+ if allowErrors {
+ conf = loader.Config{
+ AllowErrors: true,
+ TypeChecker: types.Config{
+ Error: func(e error) {},
+ },
+ }
+ }
+ for _, imp := range ambientImports {
+ conf.Import(imp)
+ }
+
+ for _, imp := range namedTypes {
+ if imp.Package != "" {
+ conf.Import(imp.Package)
+ }
+ }
+
+ return conf.Load()
+}
+
+func resolvePkg(pkgName string) (string, error) {
+ cwd, _ := os.Getwd()
+
+ pkg, err := build.Default.Import(pkgName, cwd, build.FindOnly)
+ if err != nil {
+ return "", err
+ }
+
+ return pkg.ImportPath, nil
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/codegen.go b/vendor/github.com/vektah/gqlgen/codegen/codegen.go
new file mode 100644
index 00000000..789ef2ec
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/codegen.go
@@ -0,0 +1,153 @@
+package codegen
+
+import (
+ "bytes"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "regexp"
+ "syscall"
+
+ "github.com/pkg/errors"
+ "github.com/vektah/gqlgen/codegen/templates"
+ "github.com/vektah/gqlgen/neelance/schema"
+ "golang.org/x/tools/imports"
+)
+
+func Generate(cfg Config) error {
+ if err := cfg.normalize(); err != nil {
+ return err
+ }
+
+ _ = syscall.Unlink(cfg.Exec.Filename)
+ _ = syscall.Unlink(cfg.Model.Filename)
+
+ modelsBuild, err := cfg.models()
+ if err != nil {
+ return errors.Wrap(err, "model plan failed")
+ }
+ if len(modelsBuild.Models) > 0 || len(modelsBuild.Enums) > 0 {
+ var buf *bytes.Buffer
+ buf, err = templates.Run("models.gotpl", modelsBuild)
+ if err != nil {
+ return errors.Wrap(err, "model generation failed")
+ }
+
+ if err = write(cfg.Model.Filename, buf.Bytes()); err != nil {
+ return err
+ }
+ for _, model := range modelsBuild.Models {
+ modelCfg := cfg.Models[model.GQLType]
+ modelCfg.Model = cfg.Model.ImportPath() + "." + model.GoType
+ cfg.Models[model.GQLType] = modelCfg
+ }
+
+ for _, enum := range modelsBuild.Enums {
+ modelCfg := cfg.Models[enum.GQLType]
+ modelCfg.Model = cfg.Model.ImportPath() + "." + enum.GoType
+ cfg.Models[enum.GQLType] = modelCfg
+ }
+ }
+
+ build, err := cfg.bind()
+ if err != nil {
+ return errors.Wrap(err, "exec plan failed")
+ }
+
+ var buf *bytes.Buffer
+ buf, err = templates.Run("generated.gotpl", build)
+ if err != nil {
+ return errors.Wrap(err, "exec codegen failed")
+ }
+
+ if err = write(cfg.Exec.Filename, buf.Bytes()); err != nil {
+ return err
+ }
+
+ if err = cfg.validate(); err != nil {
+ return errors.Wrap(err, "validation failed")
+ }
+
+ return nil
+}
+
+func (cfg *Config) normalize() error {
+ if err := cfg.Model.normalize(); err != nil {
+ return errors.Wrap(err, "model")
+ }
+
+ if err := cfg.Exec.normalize(); err != nil {
+ return errors.Wrap(err, "exec")
+ }
+
+ builtins := TypeMap{
+ "__Directive": {Model: "github.com/vektah/gqlgen/neelance/introspection.Directive"},
+ "__Type": {Model: "github.com/vektah/gqlgen/neelance/introspection.Type"},
+ "__Field": {Model: "github.com/vektah/gqlgen/neelance/introspection.Field"},
+ "__EnumValue": {Model: "github.com/vektah/gqlgen/neelance/introspection.EnumValue"},
+ "__InputValue": {Model: "github.com/vektah/gqlgen/neelance/introspection.InputValue"},
+ "__Schema": {Model: "github.com/vektah/gqlgen/neelance/introspection.Schema"},
+ "Int": {Model: "github.com/vektah/gqlgen/graphql.Int"},
+ "Float": {Model: "github.com/vektah/gqlgen/graphql.Float"},
+ "String": {Model: "github.com/vektah/gqlgen/graphql.String"},
+ "Boolean": {Model: "github.com/vektah/gqlgen/graphql.Boolean"},
+ "ID": {Model: "github.com/vektah/gqlgen/graphql.ID"},
+ "Time": {Model: "github.com/vektah/gqlgen/graphql.Time"},
+ "Map": {Model: "github.com/vektah/gqlgen/graphql.Map"},
+ }
+
+ if cfg.Models == nil {
+ cfg.Models = TypeMap{}
+ }
+ for typeName, entry := range builtins {
+ if !cfg.Models.Exists(typeName) {
+ cfg.Models[typeName] = entry
+ }
+ }
+
+ cfg.schema = schema.New()
+ return cfg.schema.Parse(cfg.SchemaStr)
+}
+
+var invalidPackageNameChar = regexp.MustCompile(`[^\w]`)
+
+func sanitizePackageName(pkg string) string {
+ return invalidPackageNameChar.ReplaceAllLiteralString(filepath.Base(pkg), "_")
+}
+
+func abs(path string) string {
+ absPath, err := filepath.Abs(path)
+ if err != nil {
+ panic(err)
+ }
+ return filepath.ToSlash(absPath)
+}
+
+func gofmt(filename string, b []byte) ([]byte, error) {
+ out, err := imports.Process(filename, b, nil)
+ if err != nil {
+ return b, errors.Wrap(err, "unable to gofmt")
+ }
+ return out, nil
+}
+
+func write(filename string, b []byte) error {
+ err := os.MkdirAll(filepath.Dir(filename), 0755)
+ if err != nil {
+ return errors.Wrap(err, "failed to create directory")
+ }
+
+ formatted, err := gofmt(filename, b)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "gofmt failed: %s\n", err.Error())
+ formatted = b
+ }
+
+ err = ioutil.WriteFile(filename, formatted, 0644)
+ if err != nil {
+ return errors.Wrapf(err, "failed to write %s", filename)
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/config.go b/vendor/github.com/vektah/gqlgen/codegen/config.go
new file mode 100644
index 00000000..cd42ae6b
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/config.go
@@ -0,0 +1,184 @@
+package codegen
+
+import (
+ "fmt"
+ "go/build"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "strings"
+
+ "github.com/pkg/errors"
+ "github.com/vektah/gqlgen/neelance/schema"
+ "gopkg.in/yaml.v2"
+)
+
+var defaults = Config{
+ SchemaFilename: "schema.graphql",
+ Model: PackageConfig{Filename: "models_gen.go"},
+ Exec: PackageConfig{Filename: "generated.go"},
+}
+
+var cfgFilenames = []string{".gqlgen.yml", "gqlgen.yml", "gqlgen.yaml"}
+
+// LoadDefaultConfig looks for a config file in the current directory, and all parent directories
+// walking up the tree. The closest config file will be returned.
+func LoadDefaultConfig() (*Config, error) {
+ cfgFile, err := findCfg()
+ if err != nil || cfgFile == "" {
+ cpy := defaults
+ return &cpy, err
+ }
+
+ err = os.Chdir(filepath.Dir(cfgFile))
+ if err != nil {
+ return nil, errors.Wrap(err, "unable to enter config dir")
+ }
+ return LoadConfig(cfgFile)
+}
+
+// LoadConfig reads the gqlgen.yml config file
+func LoadConfig(filename string) (*Config, error) {
+ config := defaults
+
+ b, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, errors.Wrap(err, "unable to read config")
+ }
+
+ if err := yaml.UnmarshalStrict(b, &config); err != nil {
+ return nil, errors.Wrap(err, "unable to parse config")
+ }
+
+ return &config, nil
+}
+
+type Config struct {
+ SchemaFilename string `yaml:"schema,omitempty"`
+ SchemaStr string `yaml:"-"`
+ Exec PackageConfig `yaml:"exec"`
+ Model PackageConfig `yaml:"model"`
+ Models TypeMap `yaml:"models,omitempty"`
+
+ schema *schema.Schema `yaml:"-"`
+}
+
+type PackageConfig struct {
+ Filename string `yaml:"filename,omitempty"`
+ Package string `yaml:"package,omitempty"`
+}
+
+type TypeMapEntry struct {
+ Model string `yaml:"model"`
+ Fields map[string]TypeMapField `yaml:"fields,omitempty"`
+}
+
+type TypeMapField struct {
+ Resolver bool `yaml:"resolver"`
+}
+
+func (c *PackageConfig) normalize() error {
+ if c.Filename == "" {
+ return errors.New("Filename is required")
+ }
+ c.Filename = abs(c.Filename)
+ // If Package is not set, first attempt to load the package at the output dir. If that fails
+ // fallback to just the base dir name of the output filename.
+ if c.Package == "" {
+ cwd, _ := os.Getwd()
+ pkg, _ := build.Default.Import(c.ImportPath(), cwd, 0)
+ if pkg.Name != "" {
+ c.Package = pkg.Name
+ } else {
+ c.Package = filepath.Base(c.Dir())
+ }
+ }
+ c.Package = sanitizePackageName(c.Package)
+ return nil
+}
+
+func (c *PackageConfig) ImportPath() string {
+ dir := filepath.ToSlash(c.Dir())
+ for _, gopath := range filepath.SplitList(build.Default.GOPATH) {
+ gopath = filepath.ToSlash(gopath) + "/src/"
+ if len(gopath) > len(dir) {
+ continue
+ }
+ if strings.EqualFold(gopath, dir[0:len(gopath)]) {
+ dir = dir[len(gopath):]
+ break
+ }
+ }
+ return dir
+}
+
+func (c *PackageConfig) Dir() string {
+ return filepath.ToSlash(filepath.Dir(c.Filename))
+}
+
+func (c *PackageConfig) Check() error {
+ if strings.ContainsAny(c.Package, "./\\") {
+ return fmt.Errorf("package should be the output package name only, do not include the output filename")
+ }
+ if c.Filename != "" && !strings.HasSuffix(c.Filename, ".go") {
+ return fmt.Errorf("filename should be path to a go source file")
+ }
+ return nil
+}
+
+func (cfg *Config) Check() error {
+ if err := cfg.Models.Check(); err != nil {
+ return errors.Wrap(err, "config.models")
+ }
+ if err := cfg.Exec.Check(); err != nil {
+ return errors.Wrap(err, "config.exec")
+ }
+ if err := cfg.Model.Check(); err != nil {
+ return errors.Wrap(err, "config.model")
+ }
+ return nil
+}
+
+type TypeMap map[string]TypeMapEntry
+
+func (tm TypeMap) Exists(typeName string) bool {
+ _, ok := tm[typeName]
+ return ok
+}
+
+func (tm TypeMap) Check() error {
+ for typeName, entry := range tm {
+ if strings.LastIndex(entry.Model, ".") < strings.LastIndex(entry.Model, "/") {
+ return fmt.Errorf("model %s: invalid type specifier \"%s\" - you need to specify a struct to map to", typeName, entry.Model)
+ }
+ }
+ return nil
+}
+
+// findCfg searches for the config file in this directory and all parents up the tree
+// looking for the closest match
+func findCfg() (string, error) {
+ dir, err := os.Getwd()
+ if err != nil {
+ return "", errors.Wrap(err, "unable to get working dir to findCfg")
+ }
+
+ cfg := findCfgInDir(dir)
+
+ for cfg == "" && dir != filepath.Dir(dir) {
+ dir = filepath.Dir(dir)
+ cfg = findCfgInDir(dir)
+ }
+
+ return cfg, nil
+}
+
+func findCfgInDir(dir string) string {
+ for _, cfgName := range cfgFilenames {
+ path := filepath.Join(dir, cfgName)
+ if _, err := os.Stat(path); err == nil {
+ return path
+ }
+ }
+ return ""
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/enum.go b/vendor/github.com/vektah/gqlgen/codegen/enum.go
new file mode 100644
index 00000000..e62fd2b1
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/enum.go
@@ -0,0 +1,12 @@
+package codegen
+
+type Enum struct {
+ *NamedType
+
+ Values []EnumValue
+}
+
+type EnumValue struct {
+ Name string
+ Description string
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/enum_build.go b/vendor/github.com/vektah/gqlgen/codegen/enum_build.go
new file mode 100644
index 00000000..f2e6f63c
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/enum_build.go
@@ -0,0 +1,39 @@
+package codegen
+
+import (
+ "sort"
+ "strings"
+
+ "github.com/vektah/gqlgen/codegen/templates"
+ "github.com/vektah/gqlgen/neelance/schema"
+)
+
+func (cfg *Config) buildEnums(types NamedTypes) []Enum {
+ var enums []Enum
+
+ for _, typ := range cfg.schema.Types {
+ namedType := types[typ.TypeName()]
+ e, isEnum := typ.(*schema.Enum)
+ if !isEnum || strings.HasPrefix(typ.TypeName(), "__") || namedType.IsUserDefined {
+ continue
+ }
+
+ var values []EnumValue
+ for _, v := range e.Values {
+ values = append(values, EnumValue{v.Name, v.Desc})
+ }
+
+ enum := Enum{
+ NamedType: namedType,
+ Values: values,
+ }
+ enum.GoType = templates.ToCamel(enum.GQLType)
+ enums = append(enums, enum)
+ }
+
+ sort.Slice(enums, func(i, j int) bool {
+ return strings.Compare(enums[i].GQLType, enums[j].GQLType) == -1
+ })
+
+ return enums
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/import.go b/vendor/github.com/vektah/gqlgen/codegen/import.go
new file mode 100644
index 00000000..b511e8f6
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/import.go
@@ -0,0 +1,29 @@
+package codegen
+
+import (
+ "strconv"
+)
+
+type Import struct {
+ Name string
+ Path string
+
+ alias string
+}
+
+type Imports struct {
+ imports []*Import
+ destDir string
+}
+
+func (i *Import) Write() string {
+ return i.Alias() + " " + strconv.Quote(i.Path)
+}
+
+func (i *Import) Alias() string {
+ if i.alias == "" {
+ panic("alias called before imports are finalized")
+ }
+
+ return i.alias
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/import_build.go b/vendor/github.com/vektah/gqlgen/codegen/import_build.go
new file mode 100644
index 00000000..f0877ed3
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/import_build.go
@@ -0,0 +1,116 @@
+package codegen
+
+import (
+ "fmt"
+ "go/build"
+ "sort"
+ "strconv"
+ "strings"
+)
+
+// These imports are referenced by the generated code, and are assumed to have the
+// default alias. So lets make sure they get added first, and any later collisions get
+// renamed.
+var ambientImports = []string{
+ "context",
+ "fmt",
+ "io",
+ "strconv",
+ "time",
+ "sync",
+ "github.com/vektah/gqlgen/neelance/introspection",
+ "github.com/vektah/gqlgen/neelance/errors",
+ "github.com/vektah/gqlgen/neelance/query",
+ "github.com/vektah/gqlgen/neelance/schema",
+ "github.com/vektah/gqlgen/neelance/validation",
+ "github.com/vektah/gqlgen/graphql",
+}
+
+func buildImports(types NamedTypes, destDir string) *Imports {
+ imports := Imports{
+ destDir: destDir,
+ }
+
+ for _, ambient := range ambientImports {
+ imports.add(ambient)
+ }
+
+ // Imports from top level user types
+ for _, t := range types {
+ t.Import = imports.add(t.Package)
+ }
+
+ return &imports
+}
+
+func (s *Imports) add(path string) *Import {
+ if path == "" {
+ return nil
+ }
+
+ if stringHasSuffixFold(s.destDir, path) {
+ return nil
+ }
+
+ if existing := s.findByPath(path); existing != nil {
+ return existing
+ }
+
+ pkg, err := build.Default.Import(path, s.destDir, 0)
+ if err != nil {
+ panic(err)
+ }
+
+ imp := &Import{
+ Name: pkg.Name,
+ Path: path,
+ }
+ s.imports = append(s.imports, imp)
+
+ return imp
+}
+
+func stringHasSuffixFold(s, suffix string) bool {
+ return len(s) >= len(suffix) && strings.EqualFold(s[len(s)-len(suffix):], suffix)
+}
+
+func (s Imports) finalize() []*Import {
+ // ensure stable ordering by sorting
+ sort.Slice(s.imports, func(i, j int) bool {
+ return s.imports[i].Path > s.imports[j].Path
+ })
+
+ for _, imp := range s.imports {
+ alias := imp.Name
+
+ i := 1
+ for s.findByAlias(alias) != nil {
+ alias = imp.Name + strconv.Itoa(i)
+ i++
+ if i > 10 {
+ panic(fmt.Errorf("too many collisions, last attempt was %s", alias))
+ }
+ }
+ imp.alias = alias
+ }
+
+ return s.imports
+}
+
+func (s Imports) findByPath(importPath string) *Import {
+ for _, imp := range s.imports {
+ if imp.Path == importPath {
+ return imp
+ }
+ }
+ return nil
+}
+
+func (s Imports) findByAlias(alias string) *Import {
+ for _, imp := range s.imports {
+ if imp.alias == alias {
+ return imp
+ }
+ }
+ return nil
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/input_build.go b/vendor/github.com/vektah/gqlgen/codegen/input_build.go
new file mode 100644
index 00000000..98b25b8b
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/input_build.go
@@ -0,0 +1,86 @@
+package codegen
+
+import (
+ "go/types"
+ "sort"
+ "strings"
+
+ "github.com/pkg/errors"
+ "github.com/vektah/gqlgen/neelance/schema"
+ "golang.org/x/tools/go/loader"
+)
+
+func (cfg *Config) buildInputs(namedTypes NamedTypes, prog *loader.Program, imports *Imports) (Objects, error) {
+ var inputs Objects
+
+ for _, typ := range cfg.schema.Types {
+ switch typ := typ.(type) {
+ case *schema.InputObject:
+ input, err := buildInput(namedTypes, typ)
+ if err != nil {
+ return nil, err
+ }
+
+ def, err := findGoType(prog, input.Package, input.GoType)
+ if err != nil {
+ return nil, errors.Wrap(err, "cannot find type")
+ }
+ if def != nil {
+ input.Marshaler = buildInputMarshaler(typ, def)
+ bindErrs := bindObject(def.Type(), input, imports)
+ if len(bindErrs) > 0 {
+ return nil, bindErrs
+ }
+ }
+
+ inputs = append(inputs, input)
+ }
+ }
+
+ sort.Slice(inputs, func(i, j int) bool {
+ return strings.Compare(inputs[i].GQLType, inputs[j].GQLType) == -1
+ })
+
+ return inputs, nil
+}
+
+func buildInput(types NamedTypes, typ *schema.InputObject) (*Object, error) {
+ obj := &Object{NamedType: types[typ.TypeName()]}
+
+ for _, field := range typ.Values {
+ newField := Field{
+ GQLName: field.Name.Name,
+ Type: types.getType(field.Type),
+ Object: obj,
+ }
+
+ if field.Default != nil {
+ newField.Default = field.Default.Value(nil)
+ }
+
+ if !newField.Type.IsInput && !newField.Type.IsScalar {
+ return nil, errors.Errorf("%s cannot be used as a field of %s. only input and scalar types are allowed", newField.GQLType, obj.GQLType)
+ }
+
+ obj.Fields = append(obj.Fields, newField)
+
+ }
+ return obj, nil
+}
+
+// if user has implemented an UnmarshalGQL method on the input type manually, use it
+// otherwise we will generate one.
+func buildInputMarshaler(typ *schema.InputObject, def types.Object) *Ref {
+ switch def := def.(type) {
+ case *types.TypeName:
+ namedType := def.Type().(*types.Named)
+ for i := 0; i < namedType.NumMethods(); i++ {
+ method := namedType.Method(i)
+ if method.Name() == "UnmarshalGQL" {
+ return nil
+ }
+ }
+ }
+
+ return &Ref{GoType: typ.Name}
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/interface.go b/vendor/github.com/vektah/gqlgen/codegen/interface.go
new file mode 100644
index 00000000..2de0c88a
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/interface.go
@@ -0,0 +1,13 @@
+package codegen
+
+type Interface struct {
+ *NamedType
+
+ Implementors []InterfaceImplementor
+}
+
+type InterfaceImplementor struct {
+ ValueReceiver bool
+
+ *NamedType
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/interface_build.go b/vendor/github.com/vektah/gqlgen/codegen/interface_build.go
new file mode 100644
index 00000000..cdf0f597
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/interface_build.go
@@ -0,0 +1,94 @@
+package codegen
+
+import (
+ "fmt"
+ "go/types"
+ "os"
+ "sort"
+ "strings"
+
+ "github.com/vektah/gqlgen/neelance/schema"
+ "golang.org/x/tools/go/loader"
+)
+
+func (cfg *Config) buildInterfaces(types NamedTypes, prog *loader.Program) []*Interface {
+ var interfaces []*Interface
+ for _, typ := range cfg.schema.Types {
+ switch typ := typ.(type) {
+ case *schema.Union, *schema.Interface:
+ interfaces = append(interfaces, cfg.buildInterface(types, typ, prog))
+ default:
+ continue
+ }
+ }
+
+ sort.Slice(interfaces, func(i, j int) bool {
+ return strings.Compare(interfaces[i].GQLType, interfaces[j].GQLType) == -1
+ })
+
+ return interfaces
+}
+
+func (cfg *Config) buildInterface(types NamedTypes, typ schema.NamedType, prog *loader.Program) *Interface {
+ switch typ := typ.(type) {
+
+ case *schema.Union:
+ i := &Interface{NamedType: types[typ.TypeName()]}
+
+ for _, implementor := range typ.PossibleTypes {
+ t := types[implementor.TypeName()]
+
+ i.Implementors = append(i.Implementors, InterfaceImplementor{
+ NamedType: t,
+ ValueReceiver: cfg.isValueReceiver(types[typ.Name], t, prog),
+ })
+ }
+
+ return i
+
+ case *schema.Interface:
+ i := &Interface{NamedType: types[typ.TypeName()]}
+
+ for _, implementor := range typ.PossibleTypes {
+ t := types[implementor.TypeName()]
+
+ i.Implementors = append(i.Implementors, InterfaceImplementor{
+ NamedType: t,
+ ValueReceiver: cfg.isValueReceiver(types[typ.Name], t, prog),
+ })
+ }
+
+ return i
+ default:
+ panic(fmt.Errorf("unknown interface %#v", typ))
+ }
+}
+
+func (cfg *Config) isValueReceiver(intf *NamedType, implementor *NamedType, prog *loader.Program) bool {
+ interfaceType, err := findGoInterface(prog, intf.Package, intf.GoType)
+ if interfaceType == nil || err != nil {
+ return true
+ }
+
+ implementorType, err := findGoNamedType(prog, implementor.Package, implementor.GoType)
+ if implementorType == nil || err != nil {
+ return true
+ }
+
+ for i := 0; i < interfaceType.NumMethods(); i++ {
+ intfMethod := interfaceType.Method(i)
+
+ implMethod := findMethod(implementorType, intfMethod.Name())
+ if implMethod == nil {
+ fmt.Fprintf(os.Stderr, "missing method %s on %s\n", intfMethod.Name(), implementor.GoType)
+ return false
+ }
+
+ sig := implMethod.Type().(*types.Signature)
+ if _, isPtr := sig.Recv().Type().(*types.Pointer); isPtr {
+ return false
+ }
+ }
+
+ return true
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/model.go b/vendor/github.com/vektah/gqlgen/codegen/model.go
new file mode 100644
index 00000000..164a04d5
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/model.go
@@ -0,0 +1,15 @@
+package codegen
+
+type Model struct {
+ *NamedType
+
+ Fields []ModelField
+}
+
+type ModelField struct {
+ *Type
+ GQLName string
+ GoVarName string
+ GoFKName string
+ GoFKType string
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/models_build.go b/vendor/github.com/vektah/gqlgen/codegen/models_build.go
new file mode 100644
index 00000000..211d4bd4
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/models_build.go
@@ -0,0 +1,91 @@
+package codegen
+
+import (
+ "sort"
+ "strings"
+
+ "github.com/vektah/gqlgen/neelance/schema"
+ "golang.org/x/tools/go/loader"
+)
+
+func (cfg *Config) buildModels(types NamedTypes, prog *loader.Program) ([]Model, error) {
+ var models []Model
+
+ for _, typ := range cfg.schema.Types {
+ var model Model
+ switch typ := typ.(type) {
+ case *schema.Object:
+ obj, err := cfg.buildObject(types, typ)
+ if err != nil {
+ return nil, err
+ }
+ if obj.Root || obj.IsUserDefined {
+ continue
+ }
+ model = cfg.obj2Model(obj)
+ case *schema.InputObject:
+ obj, err := buildInput(types, typ)
+ if err != nil {
+ return nil, err
+ }
+ if obj.IsUserDefined {
+ continue
+ }
+ model = cfg.obj2Model(obj)
+ case *schema.Interface, *schema.Union:
+ intf := cfg.buildInterface(types, typ, prog)
+ if intf.IsUserDefined {
+ continue
+ }
+ model = int2Model(intf)
+ default:
+ continue
+ }
+
+ models = append(models, model)
+ }
+
+ sort.Slice(models, func(i, j int) bool {
+ return strings.Compare(models[i].GQLType, models[j].GQLType) == -1
+ })
+
+ return models, nil
+}
+
+func (cfg *Config) obj2Model(obj *Object) Model {
+ model := Model{
+ NamedType: obj.NamedType,
+ Fields: []ModelField{},
+ }
+
+ model.GoType = ucFirst(obj.GQLType)
+ model.Marshaler = &Ref{GoType: obj.GoType}
+
+ for i := range obj.Fields {
+ field := &obj.Fields[i]
+ mf := ModelField{Type: field.Type, GQLName: field.GQLName}
+
+ mf.GoVarName = ucFirst(field.GQLName)
+ if mf.IsScalar {
+ if mf.GoVarName == "Id" {
+ mf.GoVarName = "ID"
+ }
+ }
+
+ model.Fields = append(model.Fields, mf)
+ }
+
+ return model
+}
+
+func int2Model(obj *Interface) Model {
+ model := Model{
+ NamedType: obj.NamedType,
+ Fields: []ModelField{},
+ }
+
+ model.GoType = ucFirst(obj.GQLType)
+ model.Marshaler = &Ref{GoType: obj.GoType}
+
+ return model
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/object.go b/vendor/github.com/vektah/gqlgen/codegen/object.go
new file mode 100644
index 00000000..1c03c0ba
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/object.go
@@ -0,0 +1,206 @@
+package codegen
+
+import (
+ "bytes"
+ "fmt"
+ "strconv"
+ "strings"
+ "text/template"
+ "unicode"
+)
+
+type Object struct {
+ *NamedType
+
+ Fields []Field
+ Satisfies []string
+ Root bool
+ DisableConcurrency bool
+ Stream bool
+}
+
+type Field struct {
+ *Type
+
+ GQLName string // The name of the field in graphql
+ GoMethodName string // The name of the method in go, if any
+ GoVarName string // The name of the var in go, if any
+ Args []FieldArgument // A list of arguments to be passed to this field
+ ForceResolver bool // Should be emit Resolver method
+ NoErr bool // If this is bound to a go method, does that method have an error as the second argument
+ Object *Object // A link back to the parent object
+ Default interface{} // The default value
+}
+
+type FieldArgument struct {
+ *Type
+
+ GQLName string // The name of the argument in graphql
+ GoVarName string // The name of the var in go
+ Object *Object // A link back to the parent object
+ Default interface{} // The default value
+}
+
+type Objects []*Object
+
+func (o *Object) Implementors() string {
+ satisfiedBy := strconv.Quote(o.GQLType)
+ for _, s := range o.Satisfies {
+ satisfiedBy += ", " + strconv.Quote(s)
+ }
+ return "[]string{" + satisfiedBy + "}"
+}
+
+func (o *Object) HasResolvers() bool {
+ for _, f := range o.Fields {
+ if f.IsResolver() {
+ return true
+ }
+ }
+ return false
+}
+
+func (f *Field) IsResolver() bool {
+ return f.ForceResolver || f.GoMethodName == "" && f.GoVarName == ""
+}
+
+func (f *Field) IsConcurrent() bool {
+ return f.IsResolver() && !f.Object.DisableConcurrency
+}
+func (f *Field) ShortInvocation() string {
+ if !f.IsResolver() {
+ return ""
+ }
+ shortName := strings.ToUpper(f.GQLName[:1]) + f.GQLName[1:]
+ res := fmt.Sprintf("%s().%s(ctx", f.Object.GQLType, shortName)
+ if !f.Object.Root {
+ res += fmt.Sprintf(", obj")
+ }
+ for _, arg := range f.Args {
+ res += fmt.Sprintf(", %s", arg.GoVarName)
+ }
+ res += ")"
+ return res
+}
+func (f *Field) ShortResolverDeclaration() string {
+ if !f.IsResolver() {
+ return ""
+ }
+ decl := strings.TrimPrefix(f.ResolverDeclaration(), f.Object.GQLType+"_")
+ return strings.ToUpper(decl[:1]) + decl[1:]
+}
+
+func (f *Field) ResolverDeclaration() string {
+ if !f.IsResolver() {
+ return ""
+ }
+ res := fmt.Sprintf("%s_%s(ctx context.Context", f.Object.GQLType, f.GQLName)
+
+ if !f.Object.Root {
+ res += fmt.Sprintf(", obj *%s", f.Object.FullName())
+ }
+ for _, arg := range f.Args {
+ res += fmt.Sprintf(", %s %s", arg.GoVarName, arg.Signature())
+ }
+
+ result := f.Signature()
+ if f.Object.Stream {
+ result = "<-chan " + result
+ }
+
+ res += fmt.Sprintf(") (%s, error)", result)
+ return res
+}
+
+func (f *Field) CallArgs() string {
+ var args []string
+
+ if f.GoMethodName == "" {
+ args = append(args, "ctx")
+
+ if !f.Object.Root {
+ args = append(args, "obj")
+ }
+ }
+
+ for _, arg := range f.Args {
+ args = append(args, "args["+strconv.Quote(arg.GQLName)+"].("+arg.Signature()+")")
+ }
+
+ return strings.Join(args, ", ")
+}
+
+// should be in the template, but its recursive and has a bunch of args
+func (f *Field) WriteJson() string {
+ return f.doWriteJson("res", f.Type.Modifiers, false, 1)
+}
+
+func (f *Field) doWriteJson(val string, remainingMods []string, isPtr bool, depth int) string {
+ switch {
+ case len(remainingMods) > 0 && remainingMods[0] == modPtr:
+ return fmt.Sprintf("if %s == nil { return graphql.Null }\n%s", val, f.doWriteJson(val, remainingMods[1:], true, depth+1))
+
+ case len(remainingMods) > 0 && remainingMods[0] == modList:
+ if isPtr {
+ val = "*" + val
+ }
+ var arr = "arr" + strconv.Itoa(depth)
+ var index = "idx" + strconv.Itoa(depth)
+
+ return tpl(`{{.arr}} := graphql.Array{}
+ for {{.index}} := range {{.val}} {
+ {{.arr}} = append({{.arr}}, func() graphql.Marshaler {
+ rctx := graphql.GetResolverContext(ctx)
+ rctx.PushIndex({{.index}})
+ defer rctx.Pop()
+ {{ .next }}
+ }())
+ }
+ return {{.arr}}`, map[string]interface{}{
+ "val": val,
+ "arr": arr,
+ "index": index,
+ "next": f.doWriteJson(val+"["+index+"]", remainingMods[1:], false, depth+1),
+ })
+
+ case f.IsScalar:
+ if isPtr {
+ val = "*" + val
+ }
+ return f.Marshal(val)
+
+ default:
+ if !isPtr {
+ val = "&" + val
+ }
+ return fmt.Sprintf("return ec._%s(ctx, field.Selections, %s)", f.GQLType, val)
+ }
+}
+
+func (os Objects) ByName(name string) *Object {
+ for i, o := range os {
+ if strings.EqualFold(o.GQLType, name) {
+ return os[i]
+ }
+ }
+ return nil
+}
+
+func tpl(tpl string, vars map[string]interface{}) string {
+ b := &bytes.Buffer{}
+ err := template.Must(template.New("inline").Parse(tpl)).Execute(b, vars)
+ if err != nil {
+ panic(err)
+ }
+ return b.String()
+}
+
+func ucFirst(s string) string {
+ if s == "" {
+ return ""
+ }
+
+ r := []rune(s)
+ r[0] = unicode.ToUpper(r[0])
+ return string(r)
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/object_build.go b/vendor/github.com/vektah/gqlgen/codegen/object_build.go
new file mode 100644
index 00000000..0ef40fef
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/object_build.go
@@ -0,0 +1,144 @@
+package codegen
+
+import (
+ "log"
+ "sort"
+ "strings"
+
+ "github.com/pkg/errors"
+ "github.com/vektah/gqlgen/neelance/schema"
+ "golang.org/x/tools/go/loader"
+)
+
+func (cfg *Config) buildObjects(types NamedTypes, prog *loader.Program, imports *Imports) (Objects, error) {
+ var objects Objects
+
+ for _, typ := range cfg.schema.Types {
+ switch typ := typ.(type) {
+ case *schema.Object:
+ obj, err := cfg.buildObject(types, typ)
+ if err != nil {
+ return nil, err
+ }
+
+ def, err := findGoType(prog, obj.Package, obj.GoType)
+ if err != nil {
+ return nil, err
+ }
+ if def != nil {
+ for _, bindErr := range bindObject(def.Type(), obj, imports) {
+ log.Println(bindErr.Error())
+ log.Println(" Adding resolver method")
+ }
+ }
+
+ objects = append(objects, obj)
+ }
+ }
+
+ sort.Slice(objects, func(i, j int) bool {
+ return strings.Compare(objects[i].GQLType, objects[j].GQLType) == -1
+ })
+
+ return objects, nil
+}
+
+var keywords = []string{
+ "break",
+ "default",
+ "func",
+ "interface",
+ "select",
+ "case",
+ "defer",
+ "go",
+ "map",
+ "struct",
+ "chan",
+ "else",
+ "goto",
+ "package",
+ "switch",
+ "const",
+ "fallthrough",
+ "if",
+ "range",
+ "type",
+ "continue",
+ "for",
+ "import",
+ "return",
+ "var",
+}
+
+func sanitizeGoName(name string) string {
+ for _, k := range keywords {
+ if name == k {
+ return name + "_"
+ }
+ }
+ return name
+}
+
+func (cfg *Config) buildObject(types NamedTypes, typ *schema.Object) (*Object, error) {
+ obj := &Object{NamedType: types[typ.TypeName()]}
+ typeEntry, entryExists := cfg.Models[typ.TypeName()]
+
+ for _, i := range typ.Interfaces {
+ obj.Satisfies = append(obj.Satisfies, i.Name)
+ }
+
+ for _, field := range typ.Fields {
+
+ var forceResolver bool
+ if entryExists {
+ if typeField, ok := typeEntry.Fields[field.Name]; ok {
+ forceResolver = typeField.Resolver
+ }
+ }
+
+ var args []FieldArgument
+ for _, arg := range field.Args {
+ newArg := FieldArgument{
+ GQLName: arg.Name.Name,
+ Type: types.getType(arg.Type),
+ Object: obj,
+ GoVarName: sanitizeGoName(arg.Name.Name),
+ }
+
+ if !newArg.Type.IsInput && !newArg.Type.IsScalar {
+ return nil, errors.Errorf("%s cannot be used as argument of %s.%s. only input and scalar types are allowed", arg.Type, obj.GQLType, field.Name)
+ }
+
+ if arg.Default != nil {
+ newArg.Default = arg.Default.Value(nil)
+ newArg.StripPtr()
+ }
+ args = append(args, newArg)
+ }
+
+ obj.Fields = append(obj.Fields, Field{
+ GQLName: field.Name,
+ Type: types.getType(field.Type),
+ Args: args,
+ Object: obj,
+ ForceResolver: forceResolver,
+ })
+ }
+
+ for name, typ := range cfg.schema.EntryPoints {
+ schemaObj := typ.(*schema.Object)
+ if schemaObj.TypeName() != obj.GQLType {
+ continue
+ }
+
+ obj.Root = true
+ if name == "mutation" {
+ obj.DisableConcurrency = true
+ }
+ if name == "subscription" {
+ obj.Stream = true
+ }
+ }
+ return obj, nil
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/templates/args.gotpl b/vendor/github.com/vektah/gqlgen/codegen/templates/args.gotpl
new file mode 100644
index 00000000..f53aceec
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/templates/args.gotpl
@@ -0,0 +1,30 @@
+ {{- if . }}args := map[string]interface{}{} {{end}}
+ {{- range $i, $arg := . }}
+ var arg{{$i}} {{$arg.Signature }}
+ if tmp, ok := field.Args[{{$arg.GQLName|quote}}]; ok {
+ var err error
+ {{$arg.Unmarshal (print "arg" $i) "tmp" }}
+ if err != nil {
+ ec.Error(ctx, err)
+ {{- if $arg.Object.Stream }}
+ return nil
+ {{- else }}
+ return graphql.Null
+ {{- end }}
+ }
+ } {{ if $arg.Default }} else {
+ var tmp interface{} = {{ $arg.Default | dump }}
+ var err error
+ {{$arg.Unmarshal (print "arg" $i) "tmp" }}
+ if err != nil {
+ ec.Error(ctx, err)
+ {{- if $arg.Object.Stream }}
+ return nil
+ {{- else }}
+ return graphql.Null
+ {{- end }}
+ }
+ }
+ {{end }}
+ args[{{$arg.GQLName|quote}}] = arg{{$i}}
+ {{- end -}}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/templates/data.go b/vendor/github.com/vektah/gqlgen/codegen/templates/data.go
new file mode 100644
index 00000000..d6da4807
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/templates/data.go
@@ -0,0 +1,11 @@
+package templates
+
+var data = map[string]string{
+ "args.gotpl": "\t{{- if . }}args := map[string]interface{}{} {{end}}\n\t{{- range $i, $arg := . }}\n\t\tvar arg{{$i}} {{$arg.Signature }}\n\t\tif tmp, ok := field.Args[{{$arg.GQLName|quote}}]; ok {\n\t\t\tvar err error\n\t\t\t{{$arg.Unmarshal (print \"arg\" $i) \"tmp\" }}\n\t\t\tif err != nil {\n\t\t\t\tec.Error(ctx, err)\n\t\t\t\t{{- if $arg.Object.Stream }}\n\t\t\t\t\treturn nil\n\t\t\t\t{{- else }}\n\t\t\t\t\treturn graphql.Null\n\t\t\t\t{{- end }}\n\t\t\t}\n\t\t} {{ if $arg.Default }} else {\n\t\t\tvar tmp interface{} = {{ $arg.Default | dump }}\n\t\t\tvar err error\n\t\t\t{{$arg.Unmarshal (print \"arg\" $i) \"tmp\" }}\n\t\t\tif err != nil {\n\t\t\t\tec.Error(ctx, err)\n\t\t\t\t{{- if $arg.Object.Stream }}\n\t\t\t\t\treturn nil\n\t\t\t\t{{- else }}\n\t\t\t\t\treturn graphql.Null\n\t\t\t\t{{- end }}\n\t\t\t}\n\t\t}\n\t\t{{end }}\n\t\targs[{{$arg.GQLName|quote}}] = arg{{$i}}\n\t{{- end -}}\n",
+ "field.gotpl": "{{ $field := . }}\n{{ $object := $field.Object }}\n\n{{- if $object.Stream }}\n\tfunc (ec *executionContext) _{{$object.GQLType}}_{{$field.GQLName}}(ctx context.Context, field graphql.CollectedField) func() graphql.Marshaler {\n\t\t{{- template \"args.gotpl\" $field.Args }}\n\t\tctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{Field: field})\n\t\tresults, err := ec.resolvers.{{ $object.GQLType }}_{{ $field.GQLName }}({{ $field.CallArgs }})\n\t\tif err != nil {\n\t\t\tec.Error(ctx, err)\n\t\t\treturn nil\n\t\t}\n\t\treturn func() graphql.Marshaler {\n\t\t\tres, ok := <-results\n\t\t\tif !ok {\n\t\t\t\treturn nil\n\t\t\t}\n\t\t\tvar out graphql.OrderedMap\n\t\t\tout.Add(field.Alias, func() graphql.Marshaler { {{ $field.WriteJson }} }())\n\t\t\treturn &out\n\t\t}\n\t}\n{{ else }}\n\tfunc (ec *executionContext) _{{$object.GQLType}}_{{$field.GQLName}}(ctx context.Context, field graphql.CollectedField, {{if not $object.Root}}obj *{{$object.FullName}}{{end}}) graphql.Marshaler {\n\t\t{{- template \"args.gotpl\" $field.Args }}\n\n\t\t{{- if $field.IsConcurrent }}\n\t\t\tctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{\n\t\t\t\tObject: {{$object.GQLType|quote}},\n\t\t\t\tArgs: {{if $field.Args }}args{{else}}nil{{end}},\n\t\t\t\tField: field,\n\t\t\t})\n\t\t\treturn graphql.Defer(func() (ret graphql.Marshaler) {\n\t\t\t\tdefer func() {\n\t\t\t\t\tif r := recover(); r != nil {\n\t\t\t\t\t\tuserErr := ec.Recover(ctx, r)\n\t\t\t\t\t\tec.Error(ctx, userErr)\n\t\t\t\t\t\tret = graphql.Null\n\t\t\t\t\t}\n\t\t\t\t}()\n\t\t{{ else }}\n\t\t\trctx := graphql.GetResolverContext(ctx)\n\t\t\trctx.Object = {{$object.GQLType|quote}}\n\t\t\trctx.Args = {{if $field.Args }}args{{else}}nil{{end}}\n\t\t\trctx.Field = field\n\t\t\trctx.PushField(field.Alias)\n\t\t\tdefer rctx.Pop()\n\t\t{{- end }}\n\n\t\t\t{{- if $field.IsResolver }}\n\t\t\t\tresTmp, err := ec.ResolverMiddleware(ctx, func(ctx context.Context) (interface{}, error) {\n\t\t\t\t\treturn ec.resolvers.{{ $object.GQLType }}_{{ $field.GQLName }}({{ $field.CallArgs }})\n\t\t\t\t})\n\t\t\t\tif err != nil {\n\t\t\t\t\tec.Error(ctx, err)\n\t\t\t\t\treturn graphql.Null\n\t\t\t\t}\n\t\t\t\tif resTmp == nil {\n\t\t\t\t\treturn graphql.Null\n\t\t\t\t}\n\t\t\t\tres := resTmp.({{$field.Signature}})\n\t\t\t{{- else if $field.GoVarName }}\n\t\t\t\tres := obj.{{$field.GoVarName}}\n\t\t\t{{- else if $field.GoMethodName }}\n\t\t\t\t{{- if $field.NoErr }}\n\t\t\t\t\tres := {{$field.GoMethodName}}({{ $field.CallArgs }})\n\t\t\t\t{{- else }}\n\t\t\t\t\tres, err := {{$field.GoMethodName}}({{ $field.CallArgs }})\n\t\t\t\t\tif err != nil {\n\t\t\t\t\t\tec.Error(ctx, err)\n\t\t\t\t\t\treturn graphql.Null\n\t\t\t\t\t}\n\t\t\t\t{{- end }}\n\t\t\t{{- end }}\n\t\t\t{{ $field.WriteJson }}\n\t\t{{- if $field.IsConcurrent }}\n\t\t\t})\n\t\t{{- end }}\n\t}\n{{ end }}\n",
+ "generated.gotpl": "// Code generated by github.com/vektah/gqlgen, DO NOT EDIT.\n\npackage {{ .PackageName }}\n\nimport (\n{{- range $import := .Imports }}\n\t{{- $import.Write }}\n{{ end }}\n)\n\n// MakeExecutableSchema creates an ExecutableSchema from the Resolvers interface.\nfunc MakeExecutableSchema(resolvers Resolvers) graphql.ExecutableSchema {\n\treturn &executableSchema{resolvers: resolvers}\n}\n\n// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.\nfunc NewExecutableSchema(resolvers ResolverRoot) graphql.ExecutableSchema {\n\treturn MakeExecutableSchema(shortMapper{r: resolvers})\n}\n\ntype Resolvers interface {\n{{- range $object := .Objects -}}\n\t{{ range $field := $object.Fields -}}\n\t\t{{ $field.ResolverDeclaration }}\n\t{{ end }}\n{{- end }}\n}\n\ntype ResolverRoot interface {\n{{- range $object := .Objects -}}\n\t{{ if $object.HasResolvers -}}\n\t\t{{$object.GQLType}}() {{$object.GQLType}}Resolver\n\t{{ end }}\n{{- end }}\n}\n\n{{- range $object := .Objects -}}\n\t{{ if $object.HasResolvers }}\n\t\ttype {{$object.GQLType}}Resolver interface {\n\t\t{{ range $field := $object.Fields -}}\n\t\t\t{{ $field.ShortResolverDeclaration }}\n\t\t{{ end }}\n\t\t}\n\t{{- end }}\n{{- end }}\n\ntype shortMapper struct {\n\tr ResolverRoot\n}\n\n{{- range $object := .Objects -}}\n\t{{ range $field := $object.Fields -}}\n\t\t{{- if $field.IsResolver }}\n\t\t\tfunc (s shortMapper) {{ $field.ResolverDeclaration }} {\n\t\t\t\treturn s.r.{{$field.ShortInvocation}}\n\t\t\t}\n\t\t{{- end }}\n\t{{ end }}\n{{- end }}\n\ntype executableSchema struct {\n\tresolvers Resolvers\n}\n\nfunc (e *executableSchema) Schema() *schema.Schema {\n\treturn parsedSchema\n}\n\nfunc (e *executableSchema) Query(ctx context.Context, op *query.Operation) *graphql.Response {\n\t{{- if .QueryRoot }}\n\t\tec := executionContext{graphql.GetRequestContext(ctx), e.resolvers}\n\n\t\tbuf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {\n\t\t\tdata := ec._{{.QueryRoot.GQLType}}(ctx, op.Selections)\n\t\t\tvar buf bytes.Buffer\n\t\t\tdata.MarshalGQL(&buf)\n\t\t\treturn buf.Bytes()\n\t\t})\n\n\t\treturn &graphql.Response{\n\t\t\tData: buf,\n\t\t\tErrors: ec.Errors,\n\t\t}\n\t{{- else }}\n\t\treturn graphql.ErrorResponse(ctx, \"queries are not supported\")\n\t{{- end }}\n}\n\nfunc (e *executableSchema) Mutation(ctx context.Context, op *query.Operation) *graphql.Response {\n\t{{- if .MutationRoot }}\n\t\tec := executionContext{graphql.GetRequestContext(ctx), e.resolvers}\n\n\t\tbuf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {\n\t\t\tdata := ec._{{.MutationRoot.GQLType}}(ctx, op.Selections)\n\t\t\tvar buf bytes.Buffer\n\t\t\tdata.MarshalGQL(&buf)\n\t\t\treturn buf.Bytes()\n\t\t})\n\n\t\treturn &graphql.Response{\n\t\t\tData: buf,\n\t\t\tErrors: ec.Errors,\n\t\t}\n\t{{- else }}\n\t\treturn graphql.ErrorResponse(ctx, \"mutations are not supported\")\n\t{{- end }}\n}\n\nfunc (e *executableSchema) Subscription(ctx context.Context, op *query.Operation) func() *graphql.Response {\n\t{{- if .SubscriptionRoot }}\n\t\tec := executionContext{graphql.GetRequestContext(ctx), e.resolvers}\n\n\t\tnext := ec._{{.SubscriptionRoot.GQLType}}(ctx, op.Selections)\n\t\tif ec.Errors != nil {\n\t\t\treturn graphql.OneShot(&graphql.Response{Data: []byte(\"null\"), Errors: ec.Errors})\n\t\t}\n\n\t\tvar buf bytes.Buffer\n\t\treturn func() *graphql.Response {\n\t\t\tbuf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {\n\t\t\t\tbuf.Reset()\n\t\t\t\tdata := next()\n\n\t\t\t\tif data == nil {\n\t\t\t\t\treturn nil\n\t\t\t\t}\n\t\t\t\tdata.MarshalGQL(&buf)\n\t\t\t\treturn buf.Bytes()\n\t\t\t})\n\n\t\t\treturn &graphql.Response{\n\t\t\t\tData: buf,\n\t\t\t\tErrors: ec.Errors,\n\t\t\t}\n\t\t}\n\t{{- else }}\n\t\treturn graphql.OneShot(graphql.ErrorResponse(ctx, \"subscriptions are not supported\"))\n\t{{- end }}\n}\n\ntype executionContext struct {\n\t*graphql.RequestContext\n\n\tresolvers Resolvers\n}\n\n{{- range $object := .Objects }}\n\t{{ template \"object.gotpl\" $object }}\n\n\t{{- range $field := $object.Fields }}\n\t\t{{ template \"field.gotpl\" $field }}\n\t{{ end }}\n{{- end}}\n\n{{- range $interface := .Interfaces }}\n\t{{ template \"interface.gotpl\" $interface }}\n{{- end }}\n\n{{- range $input := .Inputs }}\n\t{{ template \"input.gotpl\" $input }}\n{{- end }}\n\nfunc (ec *executionContext) introspectSchema() *introspection.Schema {\n\treturn introspection.WrapSchema(parsedSchema)\n}\n\nfunc (ec *executionContext) introspectType(name string) *introspection.Type {\n\tt := parsedSchema.Resolve(name)\n\tif t == nil {\n\t\treturn nil\n\t}\n\treturn introspection.WrapType(t)\n}\n\nvar parsedSchema = schema.MustParse({{.SchemaRaw|rawQuote}})\n",
+ "input.gotpl": "\t{{- if .IsMarshaled }}\n\tfunc Unmarshal{{ .GQLType }}(v interface{}) ({{.FullName}}, error) {\n\t\tvar it {{.FullName}}\n\t\tvar asMap = v.(map[string]interface{})\n\t\t{{ range $field := .Fields}}\n\t\t\t{{- if $field.Default}}\n\t\t\t\tif _, present := asMap[{{$field.GQLName|quote}}] ; !present {\n\t\t\t\t\tasMap[{{$field.GQLName|quote}}] = {{ $field.Default | dump }}\n\t\t\t\t}\n\t\t\t{{- end}}\n\t\t{{- end }}\n\n\t\tfor k, v := range asMap {\n\t\t\tswitch k {\n\t\t\t{{- range $field := .Fields }}\n\t\t\tcase {{$field.GQLName|quote}}:\n\t\t\t\tvar err error\n\t\t\t\t{{ $field.Unmarshal (print \"it.\" $field.GoVarName) \"v\" }}\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn it, err\n\t\t\t\t}\n\t\t\t{{- end }}\n\t\t\t}\n\t\t}\n\n\t\treturn it, nil\n\t}\n\t{{- end }}\n",
+ "interface.gotpl": "{{- $interface := . }}\n\nfunc (ec *executionContext) _{{$interface.GQLType}}(ctx context.Context, sel []query.Selection, obj *{{$interface.FullName}}) graphql.Marshaler {\n\tswitch obj := (*obj).(type) {\n\tcase nil:\n\t\treturn graphql.Null\n\t{{- range $implementor := $interface.Implementors }}\n\t\t{{- if $implementor.ValueReceiver }}\n\t\t\tcase {{$implementor.FullName}}:\n\t\t\t\treturn ec._{{$implementor.GQLType}}(ctx, sel, &obj)\n\t\t{{- end}}\n\t\tcase *{{$implementor.FullName}}:\n\t\t\treturn ec._{{$implementor.GQLType}}(ctx, sel, obj)\n\t{{- end }}\n\tdefault:\n\t\tpanic(fmt.Errorf(\"unexpected type %T\", obj))\n\t}\n}\n",
+ "models.gotpl": "// Code generated by github.com/vektah/gqlgen, DO NOT EDIT.\n\npackage {{ .PackageName }}\n\nimport (\n{{- range $import := .Imports }}\n\t{{- $import.Write }}\n{{ end }}\n)\n\n{{ range $model := .Models }}\n\t{{- if .IsInterface }}\n\t\ttype {{.GoType}} interface {}\n\t{{- else }}\n\t\ttype {{.GoType}} struct {\n\t\t\t{{- range $field := .Fields }}\n\t\t\t\t{{- if $field.GoVarName }}\n\t\t\t\t\t{{ $field.GoVarName }} {{$field.Signature}} `json:\"{{$field.GQLName}}\"`\n\t\t\t\t{{- else }}\n\t\t\t\t\t{{ $field.GoFKName }} {{$field.GoFKType}}\n\t\t\t\t{{- end }}\n\t\t\t{{- end }}\n\t\t}\n\t{{- end }}\n{{- end}}\n\n{{ range $enum := .Enums }}\n\ttype {{.GoType}} string\n\tconst (\n\t{{ range $value := .Values -}}\n\t\t{{with .Description}} {{.|prefixLines \"// \"}} {{end}}\n\t\t{{$enum.GoType}}{{ .Name|toCamel }} {{$enum.GoType}} = {{.Name|quote}}\n\t{{- end }}\n\t)\n\n\tfunc (e {{.GoType}}) IsValid() bool {\n\t\tswitch e {\n\t\tcase {{ range $index, $element := .Values}}{{if $index}},{{end}}{{ $enum.GoType }}{{ $element.Name|toCamel }}{{end}}:\n\t\t\treturn true\n\t\t}\n\t\treturn false\n\t}\n\n\tfunc (e {{.GoType}}) String() string {\n\t\treturn string(e)\n\t}\n\n\tfunc (e *{{.GoType}}) UnmarshalGQL(v interface{}) error {\n\t\tstr, ok := v.(string)\n\t\tif !ok {\n\t\t\treturn fmt.Errorf(\"enums must be strings\")\n\t\t}\n\n\t\t*e = {{.GoType}}(str)\n\t\tif !e.IsValid() {\n\t\t\treturn fmt.Errorf(\"%s is not a valid {{.GQLType}}\", str)\n\t\t}\n\t\treturn nil\n\t}\n\n\tfunc (e {{.GoType}}) MarshalGQL(w io.Writer) {\n\t\tfmt.Fprint(w, strconv.Quote(e.String()))\n\t}\n\n{{- end }}\n",
+ "object.gotpl": "{{ $object := . }}\n\nvar {{ $object.GQLType|lcFirst}}Implementors = {{$object.Implementors}}\n\n// nolint: gocyclo, errcheck, gas, goconst\n{{- if .Stream }}\nfunc (ec *executionContext) _{{$object.GQLType}}(ctx context.Context, sel []query.Selection) func() graphql.Marshaler {\n\tfields := graphql.CollectFields(ec.Doc, sel, {{$object.GQLType|lcFirst}}Implementors, ec.Variables)\n\tctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{\n\t\tObject: {{$object.GQLType|quote}},\n\t})\n\tif len(fields) != 1 {\n\t\tec.Errorf(ctx, \"must subscribe to exactly one stream\")\n\t\treturn nil\n\t}\n\n\tswitch fields[0].Name {\n\t{{- range $field := $object.Fields }}\n\tcase \"{{$field.GQLName}}\":\n\t\treturn ec._{{$object.GQLType}}_{{$field.GQLName}}(ctx, fields[0])\n\t{{- end }}\n\tdefault:\n\t\tpanic(\"unknown field \" + strconv.Quote(fields[0].Name))\n\t}\n}\n{{- else }}\nfunc (ec *executionContext) _{{$object.GQLType}}(ctx context.Context, sel []query.Selection{{if not $object.Root}}, obj *{{$object.FullName}} {{end}}) graphql.Marshaler {\n\tfields := graphql.CollectFields(ec.Doc, sel, {{$object.GQLType|lcFirst}}Implementors, ec.Variables)\n\t{{if $object.Root}}\n\t\tctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{\n\t\t\tObject: {{$object.GQLType|quote}},\n\t\t})\n\t{{end}}\n\tout := graphql.NewOrderedMap(len(fields))\n\tfor i, field := range fields {\n\t\tout.Keys[i] = field.Alias\n\n\t\tswitch field.Name {\n\t\tcase \"__typename\":\n\t\t\tout.Values[i] = graphql.MarshalString({{$object.GQLType|quote}})\n\t\t{{- range $field := $object.Fields }}\n\t\tcase \"{{$field.GQLName}}\":\n\t\t\tout.Values[i] = ec._{{$object.GQLType}}_{{$field.GQLName}}(ctx, field{{if not $object.Root}}, obj{{end}})\n\t\t{{- end }}\n\t\tdefault:\n\t\t\tpanic(\"unknown field \" + strconv.Quote(field.Name))\n\t\t}\n\t}\n\n\treturn out\n}\n{{- end }}\n",
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/templates/field.gotpl b/vendor/github.com/vektah/gqlgen/codegen/templates/field.gotpl
new file mode 100644
index 00000000..4279ad8e
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/templates/field.gotpl
@@ -0,0 +1,80 @@
+{{ $field := . }}
+{{ $object := $field.Object }}
+
+{{- if $object.Stream }}
+ func (ec *executionContext) _{{$object.GQLType}}_{{$field.GQLName}}(ctx context.Context, field graphql.CollectedField) func() graphql.Marshaler {
+ {{- template "args.gotpl" $field.Args }}
+ ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{Field: field})
+ results, err := ec.resolvers.{{ $object.GQLType }}_{{ $field.GQLName }}({{ $field.CallArgs }})
+ if err != nil {
+ ec.Error(ctx, err)
+ return nil
+ }
+ return func() graphql.Marshaler {
+ res, ok := <-results
+ if !ok {
+ return nil
+ }
+ var out graphql.OrderedMap
+ out.Add(field.Alias, func() graphql.Marshaler { {{ $field.WriteJson }} }())
+ return &out
+ }
+ }
+{{ else }}
+ func (ec *executionContext) _{{$object.GQLType}}_{{$field.GQLName}}(ctx context.Context, field graphql.CollectedField, {{if not $object.Root}}obj *{{$object.FullName}}{{end}}) graphql.Marshaler {
+ {{- template "args.gotpl" $field.Args }}
+
+ {{- if $field.IsConcurrent }}
+ ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
+ Object: {{$object.GQLType|quote}},
+ Args: {{if $field.Args }}args{{else}}nil{{end}},
+ Field: field,
+ })
+ return graphql.Defer(func() (ret graphql.Marshaler) {
+ defer func() {
+ if r := recover(); r != nil {
+ userErr := ec.Recover(ctx, r)
+ ec.Error(ctx, userErr)
+ ret = graphql.Null
+ }
+ }()
+ {{ else }}
+ rctx := graphql.GetResolverContext(ctx)
+ rctx.Object = {{$object.GQLType|quote}}
+ rctx.Args = {{if $field.Args }}args{{else}}nil{{end}}
+ rctx.Field = field
+ rctx.PushField(field.Alias)
+ defer rctx.Pop()
+ {{- end }}
+
+ {{- if $field.IsResolver }}
+ resTmp, err := ec.ResolverMiddleware(ctx, func(ctx context.Context) (interface{}, error) {
+ return ec.resolvers.{{ $object.GQLType }}_{{ $field.GQLName }}({{ $field.CallArgs }})
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ return graphql.Null
+ }
+ res := resTmp.({{$field.Signature}})
+ {{- else if $field.GoVarName }}
+ res := obj.{{$field.GoVarName}}
+ {{- else if $field.GoMethodName }}
+ {{- if $field.NoErr }}
+ res := {{$field.GoMethodName}}({{ $field.CallArgs }})
+ {{- else }}
+ res, err := {{$field.GoMethodName}}({{ $field.CallArgs }})
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ {{- end }}
+ {{- end }}
+ {{ $field.WriteJson }}
+ {{- if $field.IsConcurrent }}
+ })
+ {{- end }}
+ }
+{{ end }}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/templates/generated.gotpl b/vendor/github.com/vektah/gqlgen/codegen/templates/generated.gotpl
new file mode 100644
index 00000000..cc1dc459
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/templates/generated.gotpl
@@ -0,0 +1,175 @@
+// Code generated by github.com/vektah/gqlgen, DO NOT EDIT.
+
+package {{ .PackageName }}
+
+import (
+{{- range $import := .Imports }}
+ {{- $import.Write }}
+{{ end }}
+)
+
+// MakeExecutableSchema creates an ExecutableSchema from the Resolvers interface.
+func MakeExecutableSchema(resolvers Resolvers) graphql.ExecutableSchema {
+ return &executableSchema{resolvers: resolvers}
+}
+
+// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
+func NewExecutableSchema(resolvers ResolverRoot) graphql.ExecutableSchema {
+ return MakeExecutableSchema(shortMapper{r: resolvers})
+}
+
+type Resolvers interface {
+{{- range $object := .Objects -}}
+ {{ range $field := $object.Fields -}}
+ {{ $field.ResolverDeclaration }}
+ {{ end }}
+{{- end }}
+}
+
+type ResolverRoot interface {
+{{- range $object := .Objects -}}
+ {{ if $object.HasResolvers -}}
+ {{$object.GQLType}}() {{$object.GQLType}}Resolver
+ {{ end }}
+{{- end }}
+}
+
+{{- range $object := .Objects -}}
+ {{ if $object.HasResolvers }}
+ type {{$object.GQLType}}Resolver interface {
+ {{ range $field := $object.Fields -}}
+ {{ $field.ShortResolverDeclaration }}
+ {{ end }}
+ }
+ {{- end }}
+{{- end }}
+
+type shortMapper struct {
+ r ResolverRoot
+}
+
+{{- range $object := .Objects -}}
+ {{ range $field := $object.Fields -}}
+ {{- if $field.IsResolver }}
+ func (s shortMapper) {{ $field.ResolverDeclaration }} {
+ return s.r.{{$field.ShortInvocation}}
+ }
+ {{- end }}
+ {{ end }}
+{{- end }}
+
+type executableSchema struct {
+ resolvers Resolvers
+}
+
+func (e *executableSchema) Schema() *schema.Schema {
+ return parsedSchema
+}
+
+func (e *executableSchema) Query(ctx context.Context, op *query.Operation) *graphql.Response {
+ {{- if .QueryRoot }}
+ ec := executionContext{graphql.GetRequestContext(ctx), e.resolvers}
+
+ buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
+ data := ec._{{.QueryRoot.GQLType}}(ctx, op.Selections)
+ var buf bytes.Buffer
+ data.MarshalGQL(&buf)
+ return buf.Bytes()
+ })
+
+ return &graphql.Response{
+ Data: buf,
+ Errors: ec.Errors,
+ }
+ {{- else }}
+ return graphql.ErrorResponse(ctx, "queries are not supported")
+ {{- end }}
+}
+
+func (e *executableSchema) Mutation(ctx context.Context, op *query.Operation) *graphql.Response {
+ {{- if .MutationRoot }}
+ ec := executionContext{graphql.GetRequestContext(ctx), e.resolvers}
+
+ buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
+ data := ec._{{.MutationRoot.GQLType}}(ctx, op.Selections)
+ var buf bytes.Buffer
+ data.MarshalGQL(&buf)
+ return buf.Bytes()
+ })
+
+ return &graphql.Response{
+ Data: buf,
+ Errors: ec.Errors,
+ }
+ {{- else }}
+ return graphql.ErrorResponse(ctx, "mutations are not supported")
+ {{- end }}
+}
+
+func (e *executableSchema) Subscription(ctx context.Context, op *query.Operation) func() *graphql.Response {
+ {{- if .SubscriptionRoot }}
+ ec := executionContext{graphql.GetRequestContext(ctx), e.resolvers}
+
+ next := ec._{{.SubscriptionRoot.GQLType}}(ctx, op.Selections)
+ if ec.Errors != nil {
+ return graphql.OneShot(&graphql.Response{Data: []byte("null"), Errors: ec.Errors})
+ }
+
+ var buf bytes.Buffer
+ return func() *graphql.Response {
+ buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
+ buf.Reset()
+ data := next()
+
+ if data == nil {
+ return nil
+ }
+ data.MarshalGQL(&buf)
+ return buf.Bytes()
+ })
+
+ return &graphql.Response{
+ Data: buf,
+ Errors: ec.Errors,
+ }
+ }
+ {{- else }}
+ return graphql.OneShot(graphql.ErrorResponse(ctx, "subscriptions are not supported"))
+ {{- end }}
+}
+
+type executionContext struct {
+ *graphql.RequestContext
+
+ resolvers Resolvers
+}
+
+{{- range $object := .Objects }}
+ {{ template "object.gotpl" $object }}
+
+ {{- range $field := $object.Fields }}
+ {{ template "field.gotpl" $field }}
+ {{ end }}
+{{- end}}
+
+{{- range $interface := .Interfaces }}
+ {{ template "interface.gotpl" $interface }}
+{{- end }}
+
+{{- range $input := .Inputs }}
+ {{ template "input.gotpl" $input }}
+{{- end }}
+
+func (ec *executionContext) introspectSchema() *introspection.Schema {
+ return introspection.WrapSchema(parsedSchema)
+}
+
+func (ec *executionContext) introspectType(name string) *introspection.Type {
+ t := parsedSchema.Resolve(name)
+ if t == nil {
+ return nil
+ }
+ return introspection.WrapType(t)
+}
+
+var parsedSchema = schema.MustParse({{.SchemaRaw|rawQuote}})
diff --git a/vendor/github.com/vektah/gqlgen/codegen/templates/input.gotpl b/vendor/github.com/vektah/gqlgen/codegen/templates/input.gotpl
new file mode 100644
index 00000000..6073daf4
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/templates/input.gotpl
@@ -0,0 +1,28 @@
+ {{- if .IsMarshaled }}
+ func Unmarshal{{ .GQLType }}(v interface{}) ({{.FullName}}, error) {
+ var it {{.FullName}}
+ var asMap = v.(map[string]interface{})
+ {{ range $field := .Fields}}
+ {{- if $field.Default}}
+ if _, present := asMap[{{$field.GQLName|quote}}] ; !present {
+ asMap[{{$field.GQLName|quote}}] = {{ $field.Default | dump }}
+ }
+ {{- end}}
+ {{- end }}
+
+ for k, v := range asMap {
+ switch k {
+ {{- range $field := .Fields }}
+ case {{$field.GQLName|quote}}:
+ var err error
+ {{ $field.Unmarshal (print "it." $field.GoVarName) "v" }}
+ if err != nil {
+ return it, err
+ }
+ {{- end }}
+ }
+ }
+
+ return it, nil
+ }
+ {{- end }}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/templates/interface.gotpl b/vendor/github.com/vektah/gqlgen/codegen/templates/interface.gotpl
new file mode 100644
index 00000000..817d0abe
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/templates/interface.gotpl
@@ -0,0 +1,18 @@
+{{- $interface := . }}
+
+func (ec *executionContext) _{{$interface.GQLType}}(ctx context.Context, sel []query.Selection, obj *{{$interface.FullName}}) graphql.Marshaler {
+ switch obj := (*obj).(type) {
+ case nil:
+ return graphql.Null
+ {{- range $implementor := $interface.Implementors }}
+ {{- if $implementor.ValueReceiver }}
+ case {{$implementor.FullName}}:
+ return ec._{{$implementor.GQLType}}(ctx, sel, &obj)
+ {{- end}}
+ case *{{$implementor.FullName}}:
+ return ec._{{$implementor.GQLType}}(ctx, sel, obj)
+ {{- end }}
+ default:
+ panic(fmt.Errorf("unexpected type %T", obj))
+ }
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/templates/models.gotpl b/vendor/github.com/vektah/gqlgen/codegen/templates/models.gotpl
new file mode 100644
index 00000000..e66266a5
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/templates/models.gotpl
@@ -0,0 +1,65 @@
+// Code generated by github.com/vektah/gqlgen, DO NOT EDIT.
+
+package {{ .PackageName }}
+
+import (
+{{- range $import := .Imports }}
+ {{- $import.Write }}
+{{ end }}
+)
+
+{{ range $model := .Models }}
+ {{- if .IsInterface }}
+ type {{.GoType}} interface {}
+ {{- else }}
+ type {{.GoType}} struct {
+ {{- range $field := .Fields }}
+ {{- if $field.GoVarName }}
+ {{ $field.GoVarName }} {{$field.Signature}} `json:"{{$field.GQLName}}"`
+ {{- else }}
+ {{ $field.GoFKName }} {{$field.GoFKType}}
+ {{- end }}
+ {{- end }}
+ }
+ {{- end }}
+{{- end}}
+
+{{ range $enum := .Enums }}
+ type {{.GoType}} string
+ const (
+ {{ range $value := .Values -}}
+ {{with .Description}} {{.|prefixLines "// "}} {{end}}
+ {{$enum.GoType}}{{ .Name|toCamel }} {{$enum.GoType}} = {{.Name|quote}}
+ {{- end }}
+ )
+
+ func (e {{.GoType}}) IsValid() bool {
+ switch e {
+ case {{ range $index, $element := .Values}}{{if $index}},{{end}}{{ $enum.GoType }}{{ $element.Name|toCamel }}{{end}}:
+ return true
+ }
+ return false
+ }
+
+ func (e {{.GoType}}) String() string {
+ return string(e)
+ }
+
+ func (e *{{.GoType}}) UnmarshalGQL(v interface{}) error {
+ str, ok := v.(string)
+ if !ok {
+ return fmt.Errorf("enums must be strings")
+ }
+
+ *e = {{.GoType}}(str)
+ if !e.IsValid() {
+ return fmt.Errorf("%s is not a valid {{.GQLType}}", str)
+ }
+ return nil
+ }
+
+ func (e {{.GoType}}) MarshalGQL(w io.Writer) {
+ fmt.Fprint(w, strconv.Quote(e.String()))
+ }
+
+{{- end }}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/templates/object.gotpl b/vendor/github.com/vektah/gqlgen/codegen/templates/object.gotpl
new file mode 100644
index 00000000..b531d5fe
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/templates/object.gotpl
@@ -0,0 +1,52 @@
+{{ $object := . }}
+
+var {{ $object.GQLType|lcFirst}}Implementors = {{$object.Implementors}}
+
+// nolint: gocyclo, errcheck, gas, goconst
+{{- if .Stream }}
+func (ec *executionContext) _{{$object.GQLType}}(ctx context.Context, sel []query.Selection) func() graphql.Marshaler {
+ fields := graphql.CollectFields(ec.Doc, sel, {{$object.GQLType|lcFirst}}Implementors, ec.Variables)
+ ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
+ Object: {{$object.GQLType|quote}},
+ })
+ if len(fields) != 1 {
+ ec.Errorf(ctx, "must subscribe to exactly one stream")
+ return nil
+ }
+
+ switch fields[0].Name {
+ {{- range $field := $object.Fields }}
+ case "{{$field.GQLName}}":
+ return ec._{{$object.GQLType}}_{{$field.GQLName}}(ctx, fields[0])
+ {{- end }}
+ default:
+ panic("unknown field " + strconv.Quote(fields[0].Name))
+ }
+}
+{{- else }}
+func (ec *executionContext) _{{$object.GQLType}}(ctx context.Context, sel []query.Selection{{if not $object.Root}}, obj *{{$object.FullName}} {{end}}) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.Doc, sel, {{$object.GQLType|lcFirst}}Implementors, ec.Variables)
+ {{if $object.Root}}
+ ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
+ Object: {{$object.GQLType|quote}},
+ })
+ {{end}}
+ out := graphql.NewOrderedMap(len(fields))
+ for i, field := range fields {
+ out.Keys[i] = field.Alias
+
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString({{$object.GQLType|quote}})
+ {{- range $field := $object.Fields }}
+ case "{{$field.GQLName}}":
+ out.Values[i] = ec._{{$object.GQLType}}_{{$field.GQLName}}(ctx, field{{if not $object.Root}}, obj{{end}})
+ {{- end }}
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+
+ return out
+}
+{{- end }}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/templates/templates.go b/vendor/github.com/vektah/gqlgen/codegen/templates/templates.go
new file mode 100644
index 00000000..3d29b403
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/templates/templates.go
@@ -0,0 +1,139 @@
+//go:generate go run ./inliner/inliner.go
+
+package templates
+
+import (
+ "bytes"
+ "fmt"
+ "sort"
+ "strconv"
+ "strings"
+ "text/template"
+ "unicode"
+)
+
+func Run(name string, tpldata interface{}) (*bytes.Buffer, error) {
+ t := template.New("").Funcs(template.FuncMap{
+ "ucFirst": ucFirst,
+ "lcFirst": lcFirst,
+ "quote": strconv.Quote,
+ "rawQuote": rawQuote,
+ "toCamel": ToCamel,
+ "dump": dump,
+ "prefixLines": prefixLines,
+ })
+
+ for filename, data := range data {
+ _, err := t.New(filename).Parse(data)
+ if err != nil {
+ panic(err)
+ }
+ }
+
+ buf := &bytes.Buffer{}
+ err := t.Lookup(name).Execute(buf, tpldata)
+ if err != nil {
+ return nil, err
+ }
+
+ return buf, nil
+}
+
+func ucFirst(s string) string {
+ if s == "" {
+ return ""
+ }
+ r := []rune(s)
+ r[0] = unicode.ToUpper(r[0])
+ return string(r)
+}
+
+func lcFirst(s string) string {
+ if s == "" {
+ return ""
+ }
+
+ r := []rune(s)
+ r[0] = unicode.ToLower(r[0])
+ return string(r)
+}
+
+func isDelimiter(c rune) bool {
+ return c == '-' || c == '_' || unicode.IsSpace(c)
+}
+
+func ToCamel(s string) string {
+ buffer := make([]rune, 0, len(s))
+ upper := true
+ lastWasUpper := false
+
+ for _, c := range s {
+ if isDelimiter(c) {
+ upper = true
+ continue
+ }
+ if !lastWasUpper && unicode.IsUpper(c) {
+ upper = true
+ }
+
+ if upper {
+ buffer = append(buffer, unicode.ToUpper(c))
+ } else {
+ buffer = append(buffer, unicode.ToLower(c))
+ }
+ upper = false
+ lastWasUpper = unicode.IsUpper(c)
+ }
+
+ return string(buffer)
+}
+
+func rawQuote(s string) string {
+ return "`" + strings.Replace(s, "`", "`+\"`\"+`", -1) + "`"
+}
+
+func dump(val interface{}) string {
+ switch val := val.(type) {
+ case int:
+ return strconv.Itoa(val)
+ case float64:
+ return fmt.Sprintf("%f", val)
+ case string:
+ return strconv.Quote(val)
+ case bool:
+ return strconv.FormatBool(val)
+ case nil:
+ return "nil"
+ case []interface{}:
+ var parts []string
+ for _, part := range val {
+ parts = append(parts, dump(part))
+ }
+ return "[]interface{}{" + strings.Join(parts, ",") + "}"
+ case map[string]interface{}:
+ buf := bytes.Buffer{}
+ buf.WriteString("map[string]interface{}{")
+ var keys []string
+ for key := range val {
+ keys = append(keys, key)
+ }
+ sort.Strings(keys)
+
+ for _, key := range keys {
+ data := val[key]
+
+ buf.WriteString(strconv.Quote(key))
+ buf.WriteString(":")
+ buf.WriteString(dump(data))
+ buf.WriteString(",")
+ }
+ buf.WriteString("}")
+ return buf.String()
+ default:
+ panic(fmt.Errorf("unsupported type %T", val))
+ }
+}
+
+func prefixLines(prefix, s string) string {
+ return prefix + strings.Replace(s, "\n", "\n"+prefix, -1)
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/type.go b/vendor/github.com/vektah/gqlgen/codegen/type.go
new file mode 100644
index 00000000..7af24b3c
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/type.go
@@ -0,0 +1,162 @@
+package codegen
+
+import (
+ "strconv"
+ "strings"
+)
+
+type NamedTypes map[string]*NamedType
+
+type NamedType struct {
+ Ref
+ IsScalar bool
+ IsInterface bool
+ IsInput bool
+ GQLType string // Name of the graphql type
+ Marshaler *Ref // If this type has an external marshaler this will be set
+}
+
+type Ref struct {
+ GoType string // Name of the go type
+ Package string // the package the go type lives in
+ Import *Import // the resolved import with alias
+ IsUserDefined bool // does the type exist in the typemap
+}
+
+type Type struct {
+ *NamedType
+
+ Modifiers []string
+ CastType *Ref // the type to cast to when unmarshalling
+}
+
+const (
+ modList = "[]"
+ modPtr = "*"
+)
+
+func (t Ref) FullName() string {
+ return t.PkgDot() + t.GoType
+}
+
+func (t Ref) PkgDot() string {
+ if t.Import == nil || t.Import.Alias() == "" {
+ return ""
+ }
+ return t.Import.Alias() + "."
+}
+
+func (t Type) Signature() string {
+ return strings.Join(t.Modifiers, "") + t.FullName()
+}
+
+func (t Type) FullSignature() string {
+ pkg := ""
+ if t.Package != "" {
+ pkg = t.Package + "."
+ }
+
+ return strings.Join(t.Modifiers, "") + pkg + t.GoType
+}
+
+func (t Type) IsPtr() bool {
+ return len(t.Modifiers) > 0 && t.Modifiers[0] == modPtr
+}
+
+func (t *Type) StripPtr() {
+ if !t.IsPtr() {
+ return
+ }
+ t.Modifiers = t.Modifiers[0 : len(t.Modifiers)-1]
+}
+
+func (t Type) IsSlice() bool {
+ return len(t.Modifiers) > 0 && t.Modifiers[0] == modList ||
+ len(t.Modifiers) > 1 && t.Modifiers[0] == modPtr && t.Modifiers[1] == modList
+}
+
+func (t NamedType) IsMarshaled() bool {
+ return t.Marshaler != nil
+}
+
+func (t Type) Unmarshal(result, raw string) string {
+ return t.unmarshal(result, raw, t.Modifiers, 1)
+}
+
+func (t Type) unmarshal(result, raw string, remainingMods []string, depth int) string {
+ switch {
+ case len(remainingMods) > 0 && remainingMods[0] == modPtr:
+ ptr := "ptr" + strconv.Itoa(depth)
+ return tpl(`var {{.ptr}} {{.mods}}{{.t.FullName}}
+ if {{.raw}} != nil {
+ {{.next}}
+ {{.result}} = &{{.ptr -}}
+ }
+ `, map[string]interface{}{
+ "ptr": ptr,
+ "t": t,
+ "raw": raw,
+ "result": result,
+ "mods": strings.Join(remainingMods[1:], ""),
+ "next": t.unmarshal(ptr, raw, remainingMods[1:], depth+1),
+ })
+
+ case len(remainingMods) > 0 && remainingMods[0] == modList:
+ var rawIf = "rawIf" + strconv.Itoa(depth)
+ var index = "idx" + strconv.Itoa(depth)
+
+ return tpl(`var {{.rawSlice}} []interface{}
+ if {{.raw}} != nil {
+ if tmp1, ok := {{.raw}}.([]interface{}); ok {
+ {{.rawSlice}} = tmp1
+ }
+ }
+ {{.result}} = make({{.type}}, len({{.rawSlice}}))
+ for {{.index}} := range {{.rawSlice}} {
+ {{ .next -}}
+ }`, map[string]interface{}{
+ "raw": raw,
+ "rawSlice": rawIf,
+ "index": index,
+ "result": result,
+ "type": strings.Join(remainingMods, "") + t.NamedType.FullName(),
+ "next": t.unmarshal(result+"["+index+"]", rawIf+"["+index+"]", remainingMods[1:], depth+1),
+ })
+ }
+
+ realResult := result
+ if t.CastType != nil {
+ result = "castTmp"
+ }
+
+ return tpl(`{{- if .t.CastType }}
+ var castTmp {{.t.FullName}}
+ {{ end }}
+ {{- if eq .t.GoType "map[string]interface{}" }}
+ {{- .result }} = {{.raw}}.(map[string]interface{})
+ {{- else if .t.Marshaler }}
+ {{- .result }}, err = {{ .t.Marshaler.PkgDot }}Unmarshal{{.t.Marshaler.GoType}}({{.raw}})
+ {{- else -}}
+ err = (&{{.result}}).UnmarshalGQL({{.raw}})
+ {{- end }}
+ {{- if .t.CastType }}
+ {{ .realResult }} = {{.t.CastType.FullName}}(castTmp)
+ {{- end }}`, map[string]interface{}{
+ "realResult": realResult,
+ "result": result,
+ "raw": raw,
+ "t": t,
+ })
+}
+
+func (t Type) Marshal(val string) string {
+ if t.CastType != nil {
+ val = t.GoType + "(" + val + ")"
+ }
+
+ if t.Marshaler != nil {
+ return "return " + t.Marshaler.PkgDot() + "Marshal" + t.Marshaler.GoType + "(" + val + ")"
+ }
+
+ return "return " + val
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/type_build.go b/vendor/github.com/vektah/gqlgen/codegen/type_build.go
new file mode 100644
index 00000000..ba2874b0
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/type_build.go
@@ -0,0 +1,112 @@
+package codegen
+
+import (
+ "fmt"
+ "go/types"
+ "strings"
+
+ "github.com/vektah/gqlgen/neelance/common"
+ "github.com/vektah/gqlgen/neelance/schema"
+ "golang.org/x/tools/go/loader"
+)
+
+// namedTypeFromSchema objects for every graphql type, including scalars. There should only be one instance of Type for each thing
+func (cfg *Config) buildNamedTypes() NamedTypes {
+ types := map[string]*NamedType{}
+ for _, schemaType := range cfg.schema.Types {
+ t := namedTypeFromSchema(schemaType)
+
+ if userEntry, ok := cfg.Models[t.GQLType]; ok && userEntry.Model != "" {
+ t.IsUserDefined = true
+ t.Package, t.GoType = pkgAndType(userEntry.Model)
+ } else if t.IsScalar {
+ t.Package = "github.com/vektah/gqlgen/graphql"
+ t.GoType = "String"
+ }
+
+ types[t.GQLType] = t
+ }
+ return types
+}
+
+func (cfg *Config) bindTypes(imports *Imports, namedTypes NamedTypes, destDir string, prog *loader.Program) {
+ for _, t := range namedTypes {
+ if t.Package == "" {
+ continue
+ }
+
+ def, _ := findGoType(prog, t.Package, "Marshal"+t.GoType)
+ switch def := def.(type) {
+ case *types.Func:
+ sig := def.Type().(*types.Signature)
+ cpy := t.Ref
+ t.Marshaler = &cpy
+
+ t.Package, t.GoType = pkgAndType(sig.Params().At(0).Type().String())
+ t.Import = imports.add(t.Package)
+ }
+ }
+}
+
+// namedTypeFromSchema objects for every graphql type, including primitives.
+// don't recurse into object fields or interfaces yet, lets make sure we have collected everything first.
+func namedTypeFromSchema(schemaType schema.NamedType) *NamedType {
+ switch val := schemaType.(type) {
+ case *schema.Scalar, *schema.Enum:
+ return &NamedType{GQLType: val.TypeName(), IsScalar: true}
+ case *schema.Interface, *schema.Union:
+ return &NamedType{GQLType: val.TypeName(), IsInterface: true}
+ case *schema.InputObject:
+ return &NamedType{GQLType: val.TypeName(), IsInput: true}
+ default:
+ return &NamedType{GQLType: val.TypeName()}
+ }
+}
+
+// take a string in the form github.com/package/blah.Type and split it into package and type
+func pkgAndType(name string) (string, string) {
+ parts := strings.Split(name, ".")
+ if len(parts) == 1 {
+ return "", name
+ }
+
+ return normalizeVendor(strings.Join(parts[:len(parts)-1], ".")), parts[len(parts)-1]
+}
+
+func (n NamedTypes) getType(t common.Type) *Type {
+ var modifiers []string
+ usePtr := true
+ for {
+ if _, nonNull := t.(*common.NonNull); nonNull {
+ usePtr = false
+ } else if _, nonNull := t.(*common.List); nonNull {
+ usePtr = true
+ } else {
+ if usePtr {
+ modifiers = append(modifiers, modPtr)
+ }
+ usePtr = true
+ }
+
+ switch val := t.(type) {
+ case *common.NonNull:
+ t = val.OfType
+ case *common.List:
+ modifiers = append(modifiers, modList)
+ t = val.OfType
+ case schema.NamedType:
+ t := &Type{
+ NamedType: n[val.TypeName()],
+ Modifiers: modifiers,
+ }
+
+ if t.IsInterface {
+ t.StripPtr()
+ }
+
+ return t
+ default:
+ panic(fmt.Errorf("unknown type %T", t))
+ }
+ }
+}
diff --git a/vendor/github.com/vektah/gqlgen/codegen/util.go b/vendor/github.com/vektah/gqlgen/codegen/util.go
new file mode 100644
index 00000000..5ff41074
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/codegen/util.go
@@ -0,0 +1,312 @@
+package codegen
+
+import (
+ "fmt"
+ "go/types"
+ "regexp"
+ "strings"
+
+ "github.com/pkg/errors"
+ "golang.org/x/tools/go/loader"
+)
+
+func findGoType(prog *loader.Program, pkgName string, typeName string) (types.Object, error) {
+ if pkgName == "" {
+ return nil, nil
+ }
+ fullName := typeName
+ if pkgName != "" {
+ fullName = pkgName + "." + typeName
+ }
+
+ pkgName, err := resolvePkg(pkgName)
+ if err != nil {
+ return nil, errors.Errorf("unable to resolve package for %s: %s\n", fullName, err.Error())
+ }
+
+ pkg := prog.Imported[pkgName]
+ if pkg == nil {
+ return nil, errors.Errorf("required package was not loaded: %s", fullName)
+ }
+
+ for astNode, def := range pkg.Defs {
+ if astNode.Name != typeName || def.Parent() == nil || def.Parent() != pkg.Pkg.Scope() {
+ continue
+ }
+
+ return def, nil
+ }
+
+ return nil, errors.Errorf("unable to find type %s\n", fullName)
+}
+
+func findGoNamedType(prog *loader.Program, pkgName string, typeName string) (*types.Named, error) {
+ def, err := findGoType(prog, pkgName, typeName)
+ if err != nil {
+ return nil, err
+ }
+ if def == nil {
+ return nil, nil
+ }
+
+ namedType, ok := def.Type().(*types.Named)
+ if !ok {
+ return nil, errors.Errorf("expected %s to be a named type, instead found %T\n", typeName, def.Type())
+ }
+
+ return namedType, nil
+}
+
+func findGoInterface(prog *loader.Program, pkgName string, typeName string) (*types.Interface, error) {
+ namedType, err := findGoNamedType(prog, pkgName, typeName)
+ if err != nil {
+ return nil, err
+ }
+ if namedType == nil {
+ return nil, nil
+ }
+
+ underlying, ok := namedType.Underlying().(*types.Interface)
+ if !ok {
+ return nil, errors.Errorf("expected %s to be a named interface, instead found %s", typeName, namedType.String())
+ }
+
+ return underlying, nil
+}
+
+func findMethod(typ *types.Named, name string) *types.Func {
+ for i := 0; i < typ.NumMethods(); i++ {
+ method := typ.Method(i)
+ if !method.Exported() {
+ continue
+ }
+
+ if strings.EqualFold(method.Name(), name) {
+ return method
+ }
+ }
+
+ if s, ok := typ.Underlying().(*types.Struct); ok {
+ for i := 0; i < s.NumFields(); i++ {
+ field := s.Field(i)
+ if !field.Anonymous() {
+ continue
+ }
+
+ if named, ok := field.Type().(*types.Named); ok {
+ if f := findMethod(named, name); f != nil {
+ return f
+ }
+ }
+ }
+ }
+
+ return nil
+}
+
+func findField(typ *types.Struct, name string) *types.Var {
+ for i := 0; i < typ.NumFields(); i++ {
+ field := typ.Field(i)
+ if field.Anonymous() {
+ if named, ok := field.Type().(*types.Struct); ok {
+ if f := findField(named, name); f != nil {
+ return f
+ }
+ }
+
+ if named, ok := field.Type().Underlying().(*types.Struct); ok {
+ if f := findField(named, name); f != nil {
+ return f
+ }
+ }
+ }
+
+ if !field.Exported() {
+ continue
+ }
+
+ if strings.EqualFold(field.Name(), name) {
+ return field
+ }
+ }
+ return nil
+}
+
+type BindError struct {
+ object *Object
+ field *Field
+ typ types.Type
+ methodErr error
+ varErr error
+}
+
+func (b BindError) Error() string {
+ return fmt.Sprintf(
+ "Unable to bind %s.%s to %s\n %s\n %s",
+ b.object.GQLType,
+ b.field.GQLName,
+ b.typ.String(),
+ b.methodErr.Error(),
+ b.varErr.Error(),
+ )
+}
+
+type BindErrors []BindError
+
+func (b BindErrors) Error() string {
+ var errs []string
+ for _, err := range b {
+ errs = append(errs, err.Error())
+ }
+ return strings.Join(errs, "\n\n")
+}
+
+func bindObject(t types.Type, object *Object, imports *Imports) BindErrors {
+ var errs BindErrors
+ for i := range object.Fields {
+ field := &object.Fields[i]
+
+ // first try binding to a method
+ methodErr := bindMethod(imports, t, field)
+ if methodErr == nil {
+ continue
+ }
+
+ // otherwise try binding to a var
+ varErr := bindVar(imports, t, field)
+
+ if varErr != nil {
+ errs = append(errs, BindError{
+ object: object,
+ typ: t,
+ field: field,
+ varErr: varErr,
+ methodErr: methodErr,
+ })
+ }
+ }
+ return errs
+}
+
+func bindMethod(imports *Imports, t types.Type, field *Field) error {
+ namedType, ok := t.(*types.Named)
+ if !ok {
+ return fmt.Errorf("not a named type")
+ }
+
+ method := findMethod(namedType, field.GQLName)
+ if method == nil {
+ return fmt.Errorf("no method named %s", field.GQLName)
+ }
+ sig := method.Type().(*types.Signature)
+
+ if sig.Results().Len() == 1 {
+ field.NoErr = true
+ } else if sig.Results().Len() != 2 {
+ return fmt.Errorf("method has wrong number of args")
+ }
+ newArgs, err := matchArgs(field, sig.Params())
+ if err != nil {
+ return err
+ }
+
+ result := sig.Results().At(0)
+ if err := validateTypeBinding(imports, field, result.Type()); err != nil {
+ return errors.Wrap(err, "method has wrong return type")
+ }
+
+ // success, args and return type match. Bind to method
+ field.GoMethodName = "obj." + method.Name()
+ field.Args = newArgs
+ return nil
+}
+
+func bindVar(imports *Imports, t types.Type, field *Field) error {
+ underlying, ok := t.Underlying().(*types.Struct)
+ if !ok {
+ return fmt.Errorf("not a struct")
+ }
+
+ structField := findField(underlying, field.GQLName)
+ if structField == nil {
+ return fmt.Errorf("no field named %s", field.GQLName)
+ }
+
+ if err := validateTypeBinding(imports, field, structField.Type()); err != nil {
+ return errors.Wrap(err, "field has wrong type")
+ }
+
+ // success, bind to var
+ field.GoVarName = structField.Name()
+ return nil
+}
+
+func matchArgs(field *Field, params *types.Tuple) ([]FieldArgument, error) {
+ var newArgs []FieldArgument
+
+nextArg:
+ for j := 0; j < params.Len(); j++ {
+ param := params.At(j)
+ for _, oldArg := range field.Args {
+ if strings.EqualFold(oldArg.GQLName, param.Name()) {
+ oldArg.Type.Modifiers = modifiersFromGoType(param.Type())
+ newArgs = append(newArgs, oldArg)
+ continue nextArg
+ }
+ }
+
+ // no matching arg found, abort
+ return nil, fmt.Errorf("arg %s not found on method", param.Name())
+ }
+ return newArgs, nil
+}
+
+func validateTypeBinding(imports *Imports, field *Field, goType types.Type) error {
+ gqlType := normalizeVendor(field.Type.FullSignature())
+ goTypeStr := normalizeVendor(goType.String())
+
+ if goTypeStr == gqlType || "*"+goTypeStr == gqlType || goTypeStr == "*"+gqlType {
+ field.Type.Modifiers = modifiersFromGoType(goType)
+ return nil
+ }
+
+ // deal with type aliases
+ underlyingStr := normalizeVendor(goType.Underlying().String())
+ if underlyingStr == gqlType || "*"+underlyingStr == gqlType || underlyingStr == "*"+gqlType {
+ field.Type.Modifiers = modifiersFromGoType(goType)
+ pkg, typ := pkgAndType(goType.String())
+ imp := imports.findByPath(pkg)
+ field.CastType = &Ref{GoType: typ, Import: imp}
+ return nil
+ }
+
+ return fmt.Errorf("%s is not compatible with %s", gqlType, goTypeStr)
+}
+
+func modifiersFromGoType(t types.Type) []string {
+ var modifiers []string
+ for {
+ switch val := t.(type) {
+ case *types.Pointer:
+ modifiers = append(modifiers, modPtr)
+ t = val.Elem()
+ case *types.Array:
+ modifiers = append(modifiers, modList)
+ t = val.Elem()
+ case *types.Slice:
+ modifiers = append(modifiers, modList)
+ t = val.Elem()
+ default:
+ return modifiers
+ }
+ }
+}
+
+var modsRegex = regexp.MustCompile(`^(\*|\[\])*`)
+
+func normalizeVendor(pkg string) string {
+ modifiers := modsRegex.FindAllString(pkg, 1)[0]
+ pkg = strings.TrimPrefix(pkg, modifiers)
+ parts := strings.Split(pkg, "/vendor/")
+ return modifiers + parts[len(parts)-1]
+}