Merge pull request 99designs#732 from 99designs/schemaconfig-plugin

Add a plugin for configuring gqlgen via directives

api/generate.go

@@ -8,6 +8,7 @@ import (
 	"github.com/99designs/gqlgen/plugin"
 	"github.com/99designs/gqlgen/plugin/modelgen"
 	"github.com/99designs/gqlgen/plugin/resolvergen"
+	"github.com/99designs/gqlgen/plugin/schemaconfig"
 	"github.com/pkg/errors"
 	"golang.org/x/tools/go/packages"
 )
@@ -17,6 +18,7 @@ func Generate(cfg *config.Config, option ...Option) error {
 	_ = syscall.Unlink(cfg.Model.Filename)
 
 	plugins := []plugin.Plugin{
+		schemaconfig.New(),
 		modelgen.New(),
 		resolvergen.New(),
 	}

codegen/args.go

@@ -30,7 +30,7 @@ type FieldArgument struct {
 func (f *FieldArgument) ImplDirectives() []*Directive {
 	d := make([]*Directive, 0)
 	for i := range f.Directives {
-		if !f.Directives[i].IsBuiltin() && f.Directives[i].IsLocation(ast.LocationArgumentDefinition) {
+		if !f.Directives[i].Builtin && f.Directives[i].IsLocation(ast.LocationArgumentDefinition) {
 			d = append(d, f.Directives[i])
 		}
 	}

codegen/config/config.go

@@ -18,12 +18,13 @@ import (
 )
 
 type Config struct {
-	SchemaFilename StringList    `yaml:"schema,omitempty"`
-	Exec           PackageConfig `yaml:"exec"`
-	Model          PackageConfig `yaml:"model"`
-	Resolver       PackageConfig `yaml:"resolver,omitempty"`
-	Models         TypeMap       `yaml:"models,omitempty"`
-	StructTag      string        `yaml:"struct_tag,omitempty"`
+	SchemaFilename StringList                 `yaml:"schema,omitempty"`
+	Exec           PackageConfig              `yaml:"exec"`
+	Model          PackageConfig              `yaml:"model"`
+	Resolver       PackageConfig              `yaml:"resolver,omitempty"`
+	Models         TypeMap                    `yaml:"models,omitempty"`
+	StructTag      string                     `yaml:"struct_tag,omitempty"`
+	Directives     map[string]DirectiveConfig `yaml:"directives,omitempty"`
 }
 
 var cfgFilenames = []string{".gqlgen.yml", "gqlgen.yml", "gqlgen.yaml"}
@@ -34,6 +35,17 @@ func DefaultConfig() *Config {
 		SchemaFilename: StringList{"schema.graphql"},
 		Model:          PackageConfig{Filename: "models_gen.go"},
 		Exec:           PackageConfig{Filename: "generated.go"},
+		Directives: map[string]DirectiveConfig{
+			"skip": {
+				SkipRuntime: true,
+			},
+			"include": {
+				SkipRuntime: true,
+			},
+			"deprecated": {
+				SkipRuntime: true,
+			},
+		},
 	}
 }
 
@@ -299,6 +311,10 @@ func (tm TypeMap) Add(Name string, goType string) {
 	tm[Name] = modelCfg
 }
 
+type DirectiveConfig struct {
+	SkipRuntime bool `yaml:"skip_runtime"`
+}
+
 func inStrSlice(haystack []string, needle string) bool {
 	for _, v := range haystack {
 		if needle == v {

codegen/directive.go

@@ -24,11 +24,6 @@ type Directive struct {
 	Builtin bool
 }
 
-//IsBuiltin check directive
-func (d *Directive) IsBuiltin() bool {
-	return d.Builtin || d.Name == "skip" || d.Name == "include" || d.Name == "deprecated"
-}
-
 //IsLocation check location directive
 func (d *Directive) IsLocation(location ...ast.DirectiveLocation) bool {
 	for _, l := range d.Locations {
@@ -60,11 +55,6 @@ func (b *builder) buildDirectives() (map[string]*Directive, error) {
 			return nil, errors.Errorf("directive with name %s already exists", name)
 		}
 
-		var builtin bool
-		if name == "skip" || name == "include" || name == "deprecated" {
-			builtin = true
-		}
-
 		var args []*FieldArgument
 		for _, arg := range dir.Arguments {
 			tr, err := b.Binder.TypeReference(arg.Type, nil)
@@ -92,7 +82,7 @@ func (b *builder) buildDirectives() (map[string]*Directive, error) {
 			DirectiveDefinition: dir,
 			Name:                name,
 			Args:                args,
-			Builtin:             builtin,
+			Builtin:             b.Config.Directives[name].SkipRuntime,
 		}
 	}
 
@@ -132,6 +122,7 @@ func (b *builder) getDirectives(list ast.DirectiveList) ([]*Directive, error) {
 			Name:                d.Name,
 			Args:                args,
 			DirectiveDefinition: list[i].Definition,
+			Builtin:             b.Config.Directives[d.Name].SkipRuntime,
 		}
 
 	}

codegen/field.go

@@ -298,7 +298,7 @@ func (f *Field) ImplDirectives() []*Directive {
 		loc = ast.LocationInputFieldDefinition
 	}
 	for i := range f.Directives {
-		if !f.Directives[i].IsBuiltin() && f.Directives[i].IsLocation(loc) {
+		if !f.Directives[i].Builtin && f.Directives[i].IsLocation(loc) {
 			d = append(d, f.Directives[i])
 		}
 	}

docs/content/config.md

@@ -66,3 +66,33 @@ models:
 
 Everything has defaults, so add things as you need.
 
+## Inline config with directives
+
+gqlgen ships with some builtin directives that make it a little easier to manage wiring.
+
+To start using them you first need to define them:
+```graphql
+directive @goModel(model: String, models: [String!]) on OBJECT 
+    | INPUT_OBJECT 
+    | SCALAR 
+    | ENUM 
+    | INTERFACE 
+    | UNION
+
+directive @goField(forceResolver: Boolean, name: String) on INPUT_FIELD_DEFINITION 
+    | FIELD_DEFINITION
+```
+  
+> Here be dragons
+>
+> gqlgen doesnt currently support user-configurable directives for SCALAR, ENUM, INTERFACE or UNION. This only works
+> for internal directives. You can track the progress [here](https://github.com/99designs/gqlgen/issues/760)
+
+Now you can use these directives when defining types in your schema:
+
+```graphql
+type User @goModel(model:"github.com/my/app/models.User") {
+  id:   ID!	    @goField(name:"todoId")
+  name: String! @goField(resolver: true)
+}
+```

example/config/.gqlgen.yml

@@ -15,16 +15,9 @@ resolver:
 models:
   Todo:    # Object
     fields:
-      id:
-        resolver: true
       text:
         fieldName: Description # Field
   NewTodo: # Input
     fields:
       userId:
         fieldName: UserID      # Field
-  User:
-    model: github.com/99designs/gqlgen/example/config.User
-    fields:
-      name:
-        fieldName: FullName    # Method

example/config/schema.graphql

@@ -1,3 +1,6 @@
+directive @goModel(model: String, models: [String!]) on OBJECT | INPUT_OBJECT | SCALAR | ENUM | INTERFACE | UNION
+directive @goField(forceResolver: Boolean, name: String) on INPUT_FIELD_DEFINITION | FIELD_DEFINITION
+
 type Query {
   todos: [Todo!]!
 }

example/config/todo.graphql

@@ -1,5 +1,5 @@
 type Todo {
-  id: ID!
+  id: ID! @goField(forceResolver: true)
   databaseId: Int!
   text: String!
   done: Boolean!

example/config/user.graphql

@@ -1,4 +1,5 @@
-type User {
+type User
+@goModel(model:"github.com/99designs/gqlgen/example/config.User") {
   id: ID!
-  name: String!
+  name: String! @goField(name:"FullName")
 }

plugin/schemaconfig/schemaconfig.go

@@ -0,0 +1,93 @@
+package schemaconfig
+
+import (
+	"github.com/99designs/gqlgen/codegen/config"
+	"github.com/99designs/gqlgen/plugin"
+	"github.com/vektah/gqlparser/ast"
+)
+
+func New() plugin.Plugin {
+	return &Plugin{}
+}
+
+type Plugin struct{}
+
+var _ plugin.ConfigMutator = &Plugin{}
+
+func (m *Plugin) Name() string {
+	return "schemaconfig"
+}
+
+func (m *Plugin) MutateConfig(cfg *config.Config) error {
+	if err := cfg.Check(); err != nil {
+		return err
+	}
+
+	schema, _, err := cfg.LoadSchema()
+	if err != nil {
+		return err
+	}
+
+	cfg.Directives["goModel"] = config.DirectiveConfig{
+		SkipRuntime: true,
+	}
+
+	cfg.Directives["goField"] = config.DirectiveConfig{
+		SkipRuntime: true,
+	}
+
+	for _, schemaType := range schema.Types {
+		if schemaType == schema.Query || schemaType == schema.Mutation || schemaType == schema.Subscription {
+			continue
+		}
+
+		if bd := schemaType.Directives.ForName("goModel"); bd != nil {
+			if ma := bd.Arguments.ForName("model"); ma != nil {
+				if mv, err := ma.Value.Value(nil); err == nil {
+					cfg.Models.Add(schemaType.Name, mv.(string))
+				}
+			}
+			if ma := bd.Arguments.ForName("models"); ma != nil {
+				if mvs, err := ma.Value.Value(nil); err == nil {
+					for _, mv := range mvs.([]interface{}) {
+						cfg.Models.Add(schemaType.Name, mv.(string))
+					}
+				}
+			}
+		}
+
+		if schemaType.Kind == ast.Object || schemaType.Kind == ast.InputObject {
+			for _, field := range schemaType.Fields {
+				if fd := field.Directives.ForName("goField"); fd != nil {
+					forceResolver := cfg.Models[schemaType.Name].Fields[field.Name].Resolver
+					fieldName := cfg.Models[schemaType.Name].Fields[field.Name].FieldName
+
+					if ra := fd.Arguments.ForName("forceResolver"); ra != nil {
+						if fr, err := ra.Value.Value(nil); err == nil {
+							forceResolver = fr.(bool)
+						}
+					}
+
+					if na := fd.Arguments.ForName("name"); na != nil {
+						if fr, err := na.Value.Value(nil); err == nil {
+							fieldName = fr.(string)
+						}
+					}
+
+					if cfg.Models[schemaType.Name].Fields == nil {
+						cfg.Models[schemaType.Name] = config.TypeMapEntry{
+							Model:  cfg.Models[schemaType.Name].Model,
+							Fields: map[string]config.TypeMapField{},
+						}
+					}
+
+					cfg.Models[schemaType.Name].Fields[field.Name] = config.TypeMapField{
+						FieldName: fieldName,
+						Resolver:  forceResolver,
+					}
+				}
+			}
+		}
+	}
+	return nil
+}