Extract graphql go merge into its own package

cmd/gen.go

@@ -36,16 +36,10 @@ var genCmd = cli.Command{
 			}
 		}
 
-		gen, err := codegen.New(cfg)
+		err = codegen.Generate(cfg)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err.Error())
 			os.Exit(3)
 		}
-
-		err = gen.Generate()
-		if err != nil {
-			fmt.Fprintln(os.Stderr, err.Error())
-			os.Exit(4)
-		}
 	},
 }

cmd/init.go

@@ -70,17 +70,12 @@ var initCmd = cli.Command{
 }
 
 func GenerateGraphServer(cfg *config.Config, serverFilename string) {
-	gen, err := codegen.New(cfg)
+	err := codegen.Generate(cfg)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err.Error())
 	}
 
-	if err := gen.Generate(); err != nil {
-		fmt.Fprintln(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-
-	if err := gen.GenerateServer(serverFilename); err != nil {
+	if err := codegen.GenerateServer(serverFilename, cfg); err != nil {
 		fmt.Fprintln(os.Stderr, err.Error())
 		os.Exit(1)
 	}

codegen/codegen_test.go

@@ -1,68 +1,31 @@
 package codegen
 
 import (
-	"syscall"
 	"testing"
 
 	"github.com/99designs/gqlgen/codegen/config"
 	"github.com/stretchr/testify/require"
-	"github.com/vektah/gqlparser"
-	"github.com/vektah/gqlparser/ast"
-	"github.com/vektah/gqlparser/gqlerror"
 	"golang.org/x/tools/go/loader"
 )
 
 func TestGenerateServer(t *testing.T) {
 	name := "graphserver"
-	schema := `
-	type Query {
-		user: User
-	}
-	type User {
-		id: Int
-		fist_name: String
-	}
-	enum Status {
-		OK
-		ERROR
-	}
-`
-	serverFilename := "gen/" + name + "/server/server.go"
-	gen := Generator{
-		Config: &config.Config{
-			SchemaFilename: config.SchemaFilenames{"schema.graphql"},
-			Exec:           config.PackageConfig{Filename: "gen/" + name + "/exec.go"},
-			Model:          config.PackageConfig{Filename: "gen/" + name + "/model.go"},
-			Resolver:       config.PackageConfig{Filename: "gen/" + name + "/resolver.go", Type: "Resolver"},
-		},
 
-		SchemaStr: map[string]string{"schema.graphql": schema},
+	cfg := &config.Config{
+		SchemaFilename: config.SchemaFilenames{"testdata/generateserver.graphqls"},
+		Exec:           config.PackageConfig{Filename: "gen/" + name + "/exec.go"},
+		Model:          config.PackageConfig{Filename: "gen/" + name + "/model.go"},
+		Resolver:       config.PackageConfig{Filename: "gen/" + name + "/resolver.go", Type: "Resolver"},
 	}
+	serverFilename := "gen/" + name + "/server/server.go"
 
-	err := gen.Config.Check()
-	if err != nil {
-		panic(err)
-	}
-
-	var gerr *gqlerror.Error
-	gen.schema, gerr = gqlparser.LoadSchema(&ast.Source{Name: "schema.graphql", Input: schema})
-	if gerr != nil {
-		panic(gerr)
-	}
-
-	_ = syscall.Unlink(gen.Resolver.Filename)
-	_ = syscall.Unlink(serverFilename)
-
-	err = gen.Generate()
-	require.NoError(t, err)
-
-	err = gen.GenerateServer(serverFilename)
-	require.NoError(t, err)
+	require.NoError(t, Generate(cfg))
+	require.NoError(t, GenerateServer(serverFilename, cfg))
 
 	conf := loader.Config{}
 	conf.CreateFromFilenames("gen/"+name, serverFilename)
 
-	_, err = conf.Load()
+	_, err := conf.Load()
 	require.NoError(t, err)
 
 	t.Run("list of enums", func(t *testing.T) {

codegen/config/config.go

@@ -178,23 +178,23 @@ func (c *PackageConfig) IsDefined() bool {
 	return c.Filename != ""
 }
 
-func (cfg *Config) Check() error {
-	if err := cfg.Models.Check(); err != nil {
+func (c *Config) Check() error {
+	if err := c.Models.Check(); err != nil {
 		return errors.Wrap(err, "config.models")
 	}
-	if err := cfg.Exec.Check(); err != nil {
+	if err := c.Exec.Check(); err != nil {
 		return errors.Wrap(err, "config.exec")
 	}
-	if err := cfg.Model.Check(); err != nil {
+	if err := c.Model.Check(); err != nil {
 		return errors.Wrap(err, "config.model")
 	}
-	if cfg.Resolver.IsDefined() {
-		if err := cfg.Resolver.Check(); err != nil {
+	if c.Resolver.IsDefined() {
+		if err := c.Resolver.Check(); err != nil {
 			return errors.Wrap(err, "config.resolver")
 		}
 	}
 
-	return cfg.normalize()
+	return c.normalize()
 }
 
 type TypeMap map[string]TypeMapEntry
@@ -280,17 +280,17 @@ func findCfgInDir(dir string) string {
 	return ""
 }
 
-func (cfg *Config) normalize() error {
-	if err := cfg.Model.normalize(); err != nil {
+func (c *Config) normalize() error {
+	if err := c.Model.normalize(); err != nil {
 		return errors.Wrap(err, "model")
 	}
 
-	if err := cfg.Exec.normalize(); err != nil {
+	if err := c.Exec.normalize(); err != nil {
 		return errors.Wrap(err, "exec")
 	}
 
-	if cfg.Resolver.IsDefined() {
-		if err := cfg.Resolver.normalize(); err != nil {
+	if c.Resolver.IsDefined() {
+		if err := c.Resolver.normalize(); err != nil {
 			return errors.Wrap(err, "resolver")
 		}
 	}
@@ -313,12 +313,12 @@ func (cfg *Config) normalize() error {
 		"Map":                 {Model: "github.com/99designs/gqlgen/graphql.Map"},
 	}
 
-	if cfg.Models == nil {
-		cfg.Models = TypeMap{}
+	if c.Models == nil {
+		c.Models = TypeMap{}
 	}
 	for typeName, entry := range builtins {
-		if !cfg.Models.Exists(typeName) {
-			cfg.Models[typeName] = entry
+		if !c.Models.Exists(typeName) {
+			c.Models[typeName] = entry
 		}
 	}