Merge remote-tracking branch 'upstream/master' into coerce-null-int

Author: Edward Ma

CHANGELOG.md

@@ -1,3 +1,10 @@
 CHANGELOG
 
+[v1.1.0](https://github.com/graph-gophers/graphql-go/releases/tag/v1.1.0) Release v1.1.0
+* [FEATURE] Add types package #437
+* [FEATURE] Expose `packer.Unmarshaler` as `decode.Unmarshaler` to the public #450
+* [FEATURE] Add location fields to type definitions #454 
+* [FEATURE] `errors.Errorf` preserves original error similar to `fmt.Errorf` #456
+* [BUGFIX] Fix duplicated __typename in response (fixes #369) #443
+
 [v1.0.0](https://github.com/graph-gophers/graphql-go/releases/tag/v1.0.0) Initial release

errors/errors.go

@@ -5,6 +5,7 @@ import (
 )
 
 type QueryError struct {
+	Err           error                  `json:"-"` // Err holds underlying if available
 	Message       string                 `json:"message"`
 	Locations     []Location             `json:"locations,omitempty"`
 	Path          []interface{}          `json:"path,omitempty"`
@@ -23,7 +24,16 @@ func (a Location) Before(b Location) bool {
 }
 
 func Errorf(format string, a ...interface{}) *QueryError {
+	// similar to fmt.Errorf, Errorf will wrap the last argument if it is an instance of error
+	var err error
+	if n := len(a); n > 0 {
+		if v, ok := a[n-1].(error); ok {
+			err = v
+		}
+	}
+
 	return &QueryError{
+		Err:     err,
 		Message: fmt.Sprintf(format, a...),
 	}
 }
@@ -39,4 +49,11 @@ func (err *QueryError) Error() string {
 	return str
 }
 
+func (err *QueryError) Unwrap() error {
+	if err == nil {
+		return nil
+	}
+	return err.Err
+}
+
 var _ error = &QueryError{}

errors/errors_test.go

@@ -0,0 +1,55 @@
+package errors
+
+import (
+	"io"
+	"testing"
+)
+
+// Is is simplified facsimile of the go 1.13 errors.Is to ensure QueryError is compatible
+func Is(err, target error) bool {
+	for err != nil {
+		if target == err {
+			return true
+		}
+
+		switch e := err.(type) {
+		case interface{ Unwrap() error }:
+			err = e.Unwrap()
+		default:
+			break
+		}
+	}
+	return false
+}
+
+func TestErrorf(t *testing.T) {
+	cause := io.EOF
+
+	t.Run("wrap error", func(t *testing.T) {
+		err := Errorf("boom: %v", cause)
+		if !Is(err, cause) {
+			t.Fatalf("expected errors.Is to return true")
+		}
+	})
+
+	t.Run("handles nil", func(t *testing.T) {
+		var err *QueryError
+		if Is(err, cause) {
+			t.Fatalf("expected errors.Is to return false")
+		}
+	})
+
+	t.Run("handle no arguments", func(t *testing.T) {
+		err := Errorf("boom")
+		if Is(err, cause) {
+			t.Fatalf("expected errors.Is to return false")
+		}
+	})
+
+	t.Run("handle non-error argument arguments", func(t *testing.T) {
+		err := Errorf("boom: %v", "shaka")
+		if Is(err, cause) {
+			t.Fatalf("expected errors.Is to return false")
+		}
+	})
+}

gqltesting/testing.go

@@ -102,6 +102,12 @@ func checkErrors(t *testing.T, want, got []*errors.QueryError) {
 	sortErrors(want)
 	sortErrors(got)
 
+	// Clear the underlying error before the DeepEqual check.  It's too
+	// much to ask the tester to include the raw failing error.
+	for _, err := range got {
+		err.Err = nil
+	}
+
 	if !reflect.DeepEqual(got, want) {
 		t.Fatalf("unexpected error: got %+v, want %+v", got, want)
 	}

internal/schema/schema.go

@@ -348,9 +348,10 @@ func parseSchema(s *types.Schema, l *common.Lexer) {
 			s.Types[input.Name] = input
 
 		case "scalar":
+			loc := l.Location()
 			name := l.ConsumeIdent()
 			directives := common.ParseDirectives(l)
-			s.Types[name] = &types.ScalarTypeDefinition{Name: name, Desc: desc, Directives: directives}
+			s.Types[name] = &types.ScalarTypeDefinition{Name: name, Desc: desc, Directives: directives, Loc: loc}
 
 		case "directive":
 			directive := parseDirectiveDef(l)
@@ -368,7 +369,7 @@ func parseSchema(s *types.Schema, l *common.Lexer) {
 }
 
 func parseObjectDef(l *common.Lexer) *types.ObjectTypeDefinition {
-	object := &types.ObjectTypeDefinition{Name: l.ConsumeIdent()}
+	object := &types.ObjectTypeDefinition{Loc: l.Location(), Name: l.ConsumeIdent()}
 
 	for {
 		if l.Peek() == '{' {
@@ -403,7 +404,7 @@ func parseObjectDef(l *common.Lexer) *types.ObjectTypeDefinition {
 }
 
 func parseInterfaceDef(l *common.Lexer) *types.InterfaceTypeDefinition {
-	i := &types.InterfaceTypeDefinition{Name: l.ConsumeIdent()}
+	i := &types.InterfaceTypeDefinition{Loc: l.Location(), Name: l.ConsumeIdent()}
 
 	i.Directives = common.ParseDirectives(l)
 
@@ -415,7 +416,7 @@ func parseInterfaceDef(l *common.Lexer) *types.InterfaceTypeDefinition {
 }
 
 func parseUnionDef(l *common.Lexer) *types.Union {
-	union := &types.Union{Name: l.ConsumeIdent()}
+	union := &types.Union{Loc: l.Location(), Name: l.ConsumeIdent()}
 
 	union.Directives = common.ParseDirectives(l)
 	l.ConsumeToken('=')
@@ -430,6 +431,7 @@ func parseUnionDef(l *common.Lexer) *types.Union {
 
 func parseInputDef(l *common.Lexer) *types.InputObject {
 	i := &types.InputObject{}
+	i.Loc = l.Location()
 	i.Name = l.ConsumeIdent()
 	i.Directives = common.ParseDirectives(l)
 	l.ConsumeToken('{')
@@ -441,13 +443,14 @@ func parseInputDef(l *common.Lexer) *types.InputObject {
 }
 
 func parseEnumDef(l *common.Lexer) *types.EnumTypeDefinition {
-	enum := &types.EnumTypeDefinition{Name: l.ConsumeIdent()}
+	enum := &types.EnumTypeDefinition{Loc: l.Location(), Name: l.ConsumeIdent()}
 
 	enum.Directives = common.ParseDirectives(l)
 	l.ConsumeToken('{')
 	for l.Peek() != '}' {
 		v := &types.EnumValueDefinition{
 			Desc:       l.DescComment(),
+			Loc:        l.Location(),
 			EnumValue:  l.ConsumeIdent(),
 			Directives: common.ParseDirectives(l),
 		}
@@ -459,7 +462,8 @@ func parseEnumDef(l *common.Lexer) *types.EnumTypeDefinition {
 }
 func parseDirectiveDef(l *common.Lexer) *types.DirectiveDefinition {
 	l.ConsumeToken('@')
-	d := &types.DirectiveDefinition{Name: l.ConsumeIdent()}
+	loc := l.Location()
+	d := &types.DirectiveDefinition{Name: l.ConsumeIdent(), Loc: loc}
 
 	if l.Peek() == '(' {
 		l.ConsumeToken('(')
@@ -484,6 +488,7 @@ func parseDirectiveDef(l *common.Lexer) *types.DirectiveDefinition {
 }
 
 func parseExtension(s *types.Schema, l *common.Lexer) {
+	loc := l.Location()
 	switch x := l.ConsumeIdent(); x {
 	case "schema":
 		l.ConsumeToken('{')
@@ -497,23 +502,23 @@ func parseExtension(s *types.Schema, l *common.Lexer) {
 
 	case "type":
 		obj := parseObjectDef(l)
-		s.Extensions = append(s.Extensions, &types.Extension{Type: obj})
+		s.Extensions = append(s.Extensions, &types.Extension{Type: obj, Loc: loc})
 
 	case "interface":
 		iface := parseInterfaceDef(l)
-		s.Extensions = append(s.Extensions, &types.Extension{Type: iface})
+		s.Extensions = append(s.Extensions, &types.Extension{Type: iface, Loc: loc})
 
 	case "union":
 		union := parseUnionDef(l)
-		s.Extensions = append(s.Extensions, &types.Extension{Type: union})
+		s.Extensions = append(s.Extensions, &types.Extension{Type: union, Loc: loc})
 
 	case "enum":
 		enum := parseEnumDef(l)
-		s.Extensions = append(s.Extensions, &types.Extension{Type: enum})
+		s.Extensions = append(s.Extensions, &types.Extension{Type: enum, Loc: loc})
 
 	case "input":
 		input := parseInputDef(l)
-		s.Extensions = append(s.Extensions, &types.Extension{Type: input})
+		s.Extensions = append(s.Extensions, &types.Extension{Type: input, Loc: loc})
 
 	default:
 		// TODO: Add ScalarTypeDefinition when adding directives
@@ -526,6 +531,7 @@ func parseFieldsDef(l *common.Lexer) types.FieldsDefinition {
 	for l.Peek() != '}' {
 		f := &types.FieldDefinition{}
 		f.Desc = l.DescComment()
+		f.Loc = l.Location()
 		f.Name = l.ConsumeIdent()
 		if l.Peek() == '(' {
 			l.ConsumeToken('(')