Update errors to use go1.13 semantics

api/generate.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"fmt"
 	"syscall"
 
 	"github.com/99designs/gqlgen/codegen"
@@ -9,7 +10,6 @@ import (
 	"github.com/99designs/gqlgen/plugin/federation"
 	"github.com/99designs/gqlgen/plugin/modelgen"
 	"github.com/99designs/gqlgen/plugin/resolvergen"
-	"github.com/pkg/errors"
 )
 
 func Generate(cfg *config.Config, option ...Option) error {
@@ -40,7 +40,7 @@ func Generate(cfg *config.Config, option ...Option) error {
 	}
 
 	if err := cfg.LoadSchema(); err != nil {
-		return errors.Wrap(err, "failed to load schema")
+		return fmt.Errorf("failed to load schema: %w", err)
 	}
 
 	for _, p := range plugins {
@@ -53,50 +53,50 @@ func Generate(cfg *config.Config, option ...Option) error {
 
 	// LoadSchema again now we have everything
 	if err := cfg.LoadSchema(); err != nil {
-		return errors.Wrap(err, "failed to load schema")
+		return fmt.Errorf("failed to load schema: %w", err)
 	}
 
 	if err := cfg.Init(); err != nil {
-		return errors.Wrap(err, "generating core failed")
+		return fmt.Errorf("generating core failed: %w", err)
 	}
 
 	for _, p := range plugins {
 		if mut, ok := p.(plugin.ConfigMutator); ok {
 			err := mut.MutateConfig(cfg)
 			if err != nil {
-				return errors.Wrap(err, p.Name())
+				return fmt.Errorf("%s: %w", p.Name(), err)
 			}
 		}
 	}
 	// Merge again now that the generated models have been injected into the typemap
 	data, err := codegen.BuildData(cfg)
 	if err != nil {
-		return errors.Wrap(err, "merging type systems failed")
+		return fmt.Errorf("merging type systems failed: %w", err)
 	}
 
 	if err = codegen.GenerateCode(data); err != nil {
-		return errors.Wrap(err, "generating core failed")
+		return fmt.Errorf("generating core failed: %w", err)
 	}
 	if err = cfg.Packages.ModTidy(); err != nil {
-		return errors.Wrap(err, "tidy failed")
+		return fmt.Errorf("tidy failed: %w", err)
 	}
 
 	for _, p := range plugins {
 		if mut, ok := p.(plugin.CodeGenerator); ok {
 			err := mut.GenerateCode(data)
 			if err != nil {
-				return errors.Wrap(err, p.Name())
+				return fmt.Errorf("%s: %w", p.Name(), err)
 			}
 		}
 	}
 
 	if err = codegen.GenerateCode(data); err != nil {
-		return errors.Wrap(err, "generating core failed")
+		return fmt.Errorf("generating core failed: %w", err)
 	}
 
 	if !cfg.SkipValidation {
 		if err := validate(cfg); err != nil {
-			return errors.Wrap(err, "validation failed")
+			return fmt.Errorf("validation failed: %w", err)
 		}
 	}
 

cmd/gen.go

@@ -1,11 +1,11 @@
 package cmd
 
 import (
+	"errors"
 	"os"
 
 	"github.com/99designs/gqlgen/api"
 	"github.com/99designs/gqlgen/codegen/config"
-	"github.com/pkg/errors"
 	"github.com/urfave/cli/v2"
 )
 
@@ -26,7 +26,7 @@ var genCmd = &cli.Command{
 			}
 		} else {
 			cfg, err = config.LoadConfigFromDefaultLocations()
-			if os.IsNotExist(errors.Cause(err)) {
+			if os.IsNotExist(errors.Unwrap(err)) {
 				cfg, err = config.LoadDefaultConfig()
 			}
 

codegen/args.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/99designs/gqlgen/codegen/config"
 	"github.com/99designs/gqlgen/codegen/templates"
-	"github.com/pkg/errors"
 	"github.com/vektah/gqlparser/v2/ast"
 )
 
@@ -67,7 +66,7 @@ func (b *builder) buildArg(obj *Object, arg *ast.ArgumentDefinition) (*FieldArgu
 	if arg.DefaultValue != nil {
 		newArg.Default, err = arg.DefaultValue.Value(nil)
 		if err != nil {
-			return nil, errors.Errorf("default value is not valid: %s", err.Error())
+			return nil, fmt.Errorf("default value is not valid: %w", err)
 		}
 	}
 

codegen/config/binder.go

@@ -1,13 +1,13 @@
 package config
 
 import (
+	"errors"
 	"fmt"
 	"go/token"
 	"go/types"
 
 	"github.com/99designs/gqlgen/codegen/templates"
 	"github.com/99designs/gqlgen/internal/code"
-	"github.com/pkg/errors"
 	"github.com/vektah/gqlparser/v2/ast"
 )
 
@@ -119,9 +119,9 @@ func (b *Binder) FindObject(pkgName string, typeName string) (types.Object, erro
 	if pkg == nil {
 		err := b.pkgs.Errors()
 		if err != nil {
-			return nil, errors.Wrapf(err, "package could not be loaded: %s", fullName)
+			return nil, fmt.Errorf("package could not be loaded: %s: %w", fullName, err)
 		}
-		return nil, errors.Errorf("required package was not loaded: %s", fullName)
+		return nil, fmt.Errorf("required package was not loaded: %s", fullName)
 	}
 
 	// function based marshalers take precedence
@@ -148,7 +148,7 @@ func (b *Binder) FindObject(pkgName string, typeName string) (types.Object, erro
 		}
 	}
 
-	return nil, errors.Errorf("unable to find type %s\n", fullName)
+	return nil, fmt.Errorf("unable to find type %s\n", fullName)
 }
 
 func (b *Binder) PointerTo(ref *TypeReference) *TypeReference {

codegen/config/config.go

@@ -10,7 +10,6 @@ import (
 	"strings"
 
 	"github.com/99designs/gqlgen/internal/code"
-	"github.com/pkg/errors"
 	"github.com/vektah/gqlparser/v2"
 	"github.com/vektah/gqlparser/v2/ast"
 	"gopkg.in/yaml.v2"
@@ -59,7 +58,7 @@ func LoadDefaultConfig() (*Config, error) {
 		var schemaRaw []byte
 		schemaRaw, err = ioutil.ReadFile(filename)
 		if err != nil {
-			return nil, errors.Wrap(err, "unable to open schema")
+			return nil, fmt.Errorf("unable to open schema: %w", err)
 		}
 
 		config.Sources = append(config.Sources, &ast.Source{Name: filename, Input: string(schemaRaw)})
@@ -78,7 +77,7 @@ func LoadConfigFromDefaultLocations() (*Config, error) {
 
 	err = os.Chdir(filepath.Dir(cfgFile))
 	if err != nil {
-		return nil, errors.Wrap(err, "unable to enter config dir")
+		return nil, fmt.Errorf("unable to enter config dir: %w", err)
 	}
 	return LoadConfig(cfgFile)
 }
@@ -96,11 +95,11 @@ func LoadConfig(filename string) (*Config, error) {
 
 	b, err := ioutil.ReadFile(filename)
 	if err != nil {
-		return nil, errors.Wrap(err, "unable to read config")
+		return nil, fmt.Errorf("unable to read config: %w", err)
 	}
 
 	if err := yaml.UnmarshalStrict(b, config); err != nil {
-		return nil, errors.Wrap(err, "unable to parse config")
+		return nil, fmt.Errorf("unable to parse config: %w", err)
 	}
 
 	if err := CompleteConfig(config); err != nil {
@@ -150,13 +149,13 @@ func CompleteConfig(config *Config) error {
 
 				return nil
 			}); err != nil {
-				return errors.Wrapf(err, "failed to walk schema at root %s", pathParts[0])
+				return fmt.Errorf("failed to walk schema at root %s: %w", pathParts[0], err)
 			}
 		} else {
 			var err error
 			matches, err = filepath.Glob(f)
 			if err != nil {
-				return errors.Wrapf(err, "failed to glob schema filename %s", f)
+				return fmt.Errorf("failed to glob schema filename %s: %w", f, err)
 			}
 		}
 
@@ -174,7 +173,7 @@ func CompleteConfig(config *Config) error {
 		var schemaRaw []byte
 		schemaRaw, err = ioutil.ReadFile(filename)
 		if err != nil {
-			return errors.Wrap(err, "unable to open schema")
+			return fmt.Errorf("unable to open schema: %w", err)
 		}
 
 		config.Sources = append(config.Sources, &ast.Source{Name: filename, Input: string(schemaRaw)})
@@ -343,10 +342,10 @@ func (c *Config) check() error {
 	fileList := map[string][]FilenamePackage{}
 
 	if err := c.Models.Check(); err != nil {
-		return errors.Wrap(err, "config.models")
+		return fmt.Errorf("config.models: %w", err)
 	}
 	if err := c.Exec.Check(); err != nil {
-		return errors.Wrap(err, "config.exec")
+		return fmt.Errorf("config.exec: %w", err)
 	}
 	fileList[c.Exec.ImportPath()] = append(fileList[c.Exec.ImportPath()], FilenamePackage{
 		Filename: c.Exec.Filename,
@@ -356,7 +355,7 @@ func (c *Config) check() error {
 
 	if c.Model.IsDefined() {
 		if err := c.Model.Check(); err != nil {
-			return errors.Wrap(err, "config.model")
+			return fmt.Errorf("config.model: %w", err)
 		}
 		fileList[c.Model.ImportPath()] = append(fileList[c.Model.ImportPath()], FilenamePackage{
 			Filename: c.Model.Filename,
@@ -366,7 +365,7 @@ func (c *Config) check() error {
 	}
 	if c.Resolver.IsDefined() {
 		if err := c.Resolver.Check(); err != nil {
-			return errors.Wrap(err, "config.resolver")
+			return fmt.Errorf("config.resolver: %w", err)
 		}
 		fileList[c.Resolver.ImportPath()] = append(fileList[c.Resolver.ImportPath()], FilenamePackage{
 			Filename: c.Resolver.Filename,
@@ -376,7 +375,7 @@ func (c *Config) check() error {
 	}
 	if c.Federation.IsDefined() {
 		if err := c.Federation.Check(); err != nil {
-			return errors.Wrap(err, "config.federation")
+			return fmt.Errorf("config.federation: %w", err)
 		}
 		fileList[c.Federation.ImportPath()] = append(fileList[c.Federation.ImportPath()], FilenamePackage{
 			Filename: c.Federation.Filename,
@@ -480,7 +479,7 @@ func inStrSlice(haystack []string, needle string) bool {
 func findCfg() (string, error) {
 	dir, err := os.Getwd()
 	if err != nil {
-		return "", errors.Wrap(err, "unable to get working dir to findCfg")
+		return "", fmt.Errorf("unable to get working dir to findCfg: %w", err)
 	}
 
 	cfg := findCfgInDir(dir)

codegen/config/config_test.go

@@ -1,12 +1,12 @@
 package config
 
 import (
+	"errors"
 	"os"
 	"path/filepath"
 	"runtime"
 	"testing"
 
-	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/vektah/gqlparser/v2"
@@ -105,7 +105,7 @@ func TestLoadDefaultConfig(t *testing.T) {
 		require.NoError(t, err)
 
 		cfg, err = LoadDefaultConfig()
-		require.True(t, os.IsNotExist(errors.Cause(err)))
+		require.True(t, os.IsNotExist(errors.Unwrap(err)))
 	})
 }
 

codegen/data.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"sort"
 
-	"github.com/pkg/errors"
 	"github.com/vektah/gqlparser/v2/ast"
 
 	"github.com/99designs/gqlgen/codegen/config"
@@ -67,22 +66,22 @@ func BuildData(cfg *config.Config) (*Data, error) {
 		case ast.Object:
 			obj, err := b.buildObject(schemaType)
 			if err != nil {
-				return nil, errors.Wrap(err, "unable to build object definition")
+				return nil, fmt.Errorf("unable to build object definition: %w", err)
 			}
 
 			s.Objects = append(s.Objects, obj)
 		case ast.InputObject:
 			input, err := b.buildObject(schemaType)
 			if err != nil {
-				return nil, errors.Wrap(err, "unable to build input definition")
+				return nil, fmt.Errorf("unable to build input definition: %w", err)
 			}
 
 			s.Inputs = append(s.Inputs, input)
 
 		case ast.Union, ast.Interface:
 			s.Interfaces[schemaType.Name], err = b.buildInterface(schemaType)
 			if err != nil {
-				return nil, errors.Wrap(err, "unable to bind to interface")
+				return nil, fmt.Errorf("unable to bind to interface: %w", err)
 			}
 		}
 	}

codegen/directive.go

@@ -6,7 +6,6 @@ import (
 	"strings"
 
 	"github.com/99designs/gqlgen/codegen/templates"
-	"github.com/pkg/errors"
 	"github.com/vektah/gqlparser/v2/ast"
 )
 
@@ -52,7 +51,7 @@ func (b *builder) buildDirectives() (map[string]*Directive, error) {
 
 	for name, dir := range b.Schema.Directives {
 		if _, ok := directives[name]; ok {
-			return nil, errors.Errorf("directive with name %s already exists", name)
+			return nil, fmt.Errorf("directive with name %s already exists", name)
 		}
 
 		var args []*FieldArgument
@@ -72,7 +71,7 @@ func (b *builder) buildDirectives() (map[string]*Directive, error) {
 				var err error
 				newArg.Default, err = arg.DefaultValue.Value(nil)
 				if err != nil {
-					return nil, errors.Errorf("default value for directive argument %s(%s) is not valid: %s", dir.Name, arg.Name, err.Error())
+					return nil, fmt.Errorf("default value for directive argument %s(%s) is not valid: %w", dir.Name, arg.Name, err)
 				}
 			}
 			args = append(args, newArg)