Merge branch 'master' into patch-1

Author: chris-ramon

.gitignore

@@ -1 +1,2 @@
 .DS_Store
+.idea

abstract_test.go

@@ -158,6 +158,147 @@ func TestIsTypeOfUsedToResolveRuntimeTypeForInterface(t *testing.T) {
 	}
 }
 
+
+func TestAppendTypeUsedToAddRuntimeCustomScalarTypeForInterface(t *testing.T) {
+
+	petType := graphql.NewInterface(graphql.InterfaceConfig{
+		Name: "Pet",
+		Fields: graphql.Fields{
+			"name": &graphql.Field{
+				Type: graphql.String,
+			},
+		},
+	})
+
+	// ie declare that Dog belongs to Pet interface
+	dogType := graphql.NewObject(graphql.ObjectConfig{
+		Name: "Dog",
+		Interfaces: []*graphql.Interface{
+			petType,
+		},
+		IsTypeOf: func(p graphql.IsTypeOfParams) bool {
+			_, ok := p.Value.(*testDog)
+			return ok
+		},
+		Fields: graphql.Fields{
+			"name": &graphql.Field{
+				Type: graphql.String,
+				Resolve: func(p graphql.ResolveParams) (interface{}, error) {
+					if dog, ok := p.Source.(*testDog); ok {
+						return dog.Name, nil
+					}
+					return nil, nil
+				},
+			},
+			"woofs": &graphql.Field{
+				Type: graphql.Boolean,
+				Resolve: func(p graphql.ResolveParams) (interface{}, error) {
+					if dog, ok := p.Source.(*testDog); ok {
+						return dog.Woofs, nil
+					}
+					return nil, nil
+				},
+			},
+		},
+	})
+	// ie declare that Cat belongs to Pet interface
+	catType := graphql.NewObject(graphql.ObjectConfig{
+		Name: "Cat",
+		Interfaces: []*graphql.Interface{
+			petType,
+		},
+		IsTypeOf: func(p graphql.IsTypeOfParams) bool {
+			_, ok := p.Value.(*testCat)
+			return ok
+		},
+		Fields: graphql.Fields{
+			"name": &graphql.Field{
+				Type: graphql.String,
+				Resolve: func(p graphql.ResolveParams) (interface{}, error) {
+					if cat, ok := p.Source.(*testCat); ok {
+						return cat.Name, nil
+					}
+					return nil, nil
+				},
+			},
+			"meows": &graphql.Field{
+				Type: graphql.Boolean,
+				Resolve: func(p graphql.ResolveParams) (interface{}, error) {
+					if cat, ok := p.Source.(*testCat); ok {
+						return cat.Meows, nil
+					}
+					return nil, nil
+				},
+			},
+		},
+	})
+	schema, err := graphql.NewSchema(graphql.SchemaConfig{
+		Query: graphql.NewObject(graphql.ObjectConfig{
+			Name: "Query",
+			Fields: graphql.Fields{
+				"pets": &graphql.Field{
+					Type: graphql.NewList(petType),
+					Resolve: func(p graphql.ResolveParams) (interface{}, error) {
+						return []interface{}{
+							&testDog{"Odie", true},
+							&testCat{"Garfield", false},
+						}, nil
+					},
+				},
+			},
+		}),
+
+	})
+	if err != nil {
+		t.Fatalf("Error in schema %v", err.Error())
+	}
+
+	//Now add types catType and dogType at runtime.
+	schema.AppendType(catType)
+	schema.AppendType(dogType)
+
+	query := `{
+	      pets {
+		name
+		... on Dog {
+		  woofs
+		}
+		... on Cat {
+		  meows
+		}
+	      }
+	    }`
+
+	expected := &graphql.Result{
+		Data: map[string]interface{}{
+			"pets": []interface{}{
+				map[string]interface{}{
+					"name":  "Odie",
+					"woofs": bool(true),
+				},
+				map[string]interface{}{
+					"name":  "Garfield",
+					"meows": bool(false),
+				},
+			},
+		},
+		Errors: nil,
+	}
+
+	result := graphql.Do(graphql.Params{
+		Schema:        schema,
+		RequestString: query,
+	})
+	if len(result.Errors) != 0 {
+		t.Fatalf("wrong result, unexpected errors: %v", result.Errors)
+	}
+	if !reflect.DeepEqual(expected, result) {
+		t.Fatalf("Unexpected result, Diff: %v", testutil.Diff(expected, result))
+	}
+}
+
+
+
 func TestIsTypeOfUsedToResolveRuntimeTypeForUnion(t *testing.T) {
 
 	dogType := graphql.NewObject(graphql.ObjectConfig{

definition.go

@@ -1,12 +1,12 @@
 package graphql
 
 import (
+	"context"
 	"fmt"
 	"reflect"
 	"regexp"
 
 	"github.com/graphql-go/graphql/language/ast"
-	"golang.org/x/net/context"
 )
 
 // Type interface for all of the possible kinds of GraphQL types
@@ -398,6 +398,7 @@ type ObjectConfig struct {
 	IsTypeOf    IsTypeOfFn  `json:"isTypeOf"`
 	Description string      `json:"description"`
 }
+
 type FieldsThunk func() Fields
 
 func NewObject(config ObjectConfig) *Object {
@@ -506,19 +507,26 @@ func defineInterfaces(ttype *Object, interfaces []*Interface) ([]*Interface, err
 	return ifaces, nil
 }
 
-func defineFieldMap(ttype Named, fields Fields) (FieldDefinitionMap, error) {
+func defineFieldMap(ttype Named, fields interface{}) (FieldDefinitionMap, error) {
+	var fieldMap Fields
+	switch fields.(type) {
+	case Fields:
+		fieldMap = fields.(Fields)
+	case FieldsThunk:
+		fieldMap = fields.(FieldsThunk)()
+	}
 
 	resultFieldMap := FieldDefinitionMap{}
 
 	err := invariant(
-		len(fields) > 0,
+		len(fieldMap) > 0,
 		fmt.Sprintf(`%v fields must be an object with field names as keys or a function which return such an object.`, ttype),
 	)
 	if err != nil {
 		return resultFieldMap, err
 	}
 
-	for fieldName, field := range fields {
+	for fieldName, field := range fieldMap {
 		if field == nil {
 			continue
 		}
@@ -988,17 +996,27 @@ func (gt *Enum) Values() []*EnumValueDefinition {
 	return gt.values
 }
 func (gt *Enum) Serialize(value interface{}) interface{} {
-	if enumValue, ok := gt.getValueLookup()[value]; ok {
+	v := value
+	if reflect.ValueOf(v).Kind() == reflect.Ptr {
+		v = reflect.Indirect(reflect.ValueOf(v)).Interface()
+	}
+	if enumValue, ok := gt.getValueLookup()[v]; ok {
 		return enumValue.Name
 	}
 	return nil
 }
 func (gt *Enum) ParseValue(value interface{}) interface{} {
-	valueStr, ok := value.(string)
-	if !ok {
+	var v string
+
+	switch value := value.(type) {
+	case string:
+		v = value
+	case *string:
+		v = *value
+	default:
 		return nil
 	}
-	if enumValue, ok := gt.getNameLookup()[valueStr]; ok {
+	if enumValue, ok := gt.getNameLookup()[v]; ok {
 		return enumValue.Value
 	}
 	return nil
@@ -1070,8 +1088,8 @@ type InputObject struct {
 
 	typeConfig InputObjectConfig
 	fields     InputObjectFieldMap
-
-	err error
+	init       bool
+	err        error
 }
 type InputObjectFieldConfig struct {
 	Type         Input       `json:"type"`
@@ -1119,7 +1137,7 @@ func NewInputObject(config InputObjectConfig) *InputObject {
 	gt.PrivateName = config.Name
 	gt.PrivateDescription = config.Description
 	gt.typeConfig = config
-	gt.fields = gt.defineFieldMap()
+	//gt.fields = gt.defineFieldMap()
 	return gt
 }
 
@@ -1165,9 +1183,14 @@ func (gt *InputObject) defineFieldMap() InputObjectFieldMap {
 		field.DefaultValue = fieldConfig.DefaultValue
 		resultFieldMap[fieldName] = field
 	}
+	gt.init = true
 	return resultFieldMap
 }
+
 func (gt *InputObject) Fields() InputObjectFieldMap {
+	if !gt.init {
+		gt.fields = gt.defineFieldMap()
+	}
 	return gt.fields
 }
 func (gt *InputObject) Name() string {
@@ -1252,8 +1275,7 @@ func (gl *List) Error() error {
 //
 // Note: the enforcement of non-nullability occurs within the executor.
 type NonNull struct {
-	PrivateName string `json:"name"` // added to conform with introspection for NonNull.Name = nil
-	OfType      Type   `json:"ofType"`
+	OfType Type `json:"ofType"`
 
 	err error
 }

definition_test.go

@@ -619,3 +619,25 @@ func TestTypeSystem_DefinitionExample_IncludesFieldsThunk(t *testing.T) {
 		t.Fatalf("Unexpected result, Diff: %v", testutil.Diff(fieldMap["s"].Type, someObject))
 	}
 }
+
+func TestTypeSystem_DefinitionExampe_AllowsCyclicFieldTypes(t *testing.T) {
+	personType := graphql.NewObject(graphql.ObjectConfig{
+		Name: "Person",
+		Fields: (graphql.FieldsThunk)(func() graphql.Fields {
+			return graphql.Fields{
+				"name": &graphql.Field{
+					Type: graphql.String,
+				},
+				"bestFriend": &graphql.Field{
+					Type: personType,
+				},
+			}
+		}),
+	})
+
+	fieldMap := personType.Fields()
+	if !reflect.DeepEqual(fieldMap["name"].Type, graphql.String) {
+		t.Fatalf("Unexpected result, Diff: %v", testutil.Diff(fieldMap["bestFriend"].Type, personType))
+	}
+
+}

enum_type_test.go

@@ -377,3 +377,47 @@ func TestTypeSystem_EnumValues_EnumValueMayBeNullable(t *testing.T) {
 		t.Fatalf("Unexpected result, Diff: %v", testutil.Diff(expected, result))
 	}
 }
+
+func TestTypeSystem_EnumValues_EnumValueMayBePointer(t *testing.T) {
+	var enumTypeTestSchema, _ = graphql.NewSchema(graphql.SchemaConfig{
+		Query: graphql.NewObject(graphql.ObjectConfig{
+			Name: "Query",
+			Fields: graphql.Fields{
+				"query": &graphql.Field{
+					Type: graphql.NewObject(graphql.ObjectConfig{
+						Name: "query",
+						Fields: graphql.Fields{
+							"color": &graphql.Field{
+								Type: enumTypeTestColorType,
+							},
+							"foo": &graphql.Field{
+								Description: "foo field",
+								Type:        graphql.Int,
+							},
+						},
+					}),
+					Resolve: func(_ graphql.ResolveParams) (interface{}, error) {
+						one := 1
+						return struct {
+							Color *int `graphql:"color"`
+							Foo   *int `graphql:"foo"`
+						}{&one, &one}, nil
+					},
+				},
+			},
+		}),
+	})
+	query := "{ query { color foo } }"
+	expected := &graphql.Result{
+		Data: map[string]interface{}{
+			"query": map[string]interface{}{
+				"color": "GREEN",
+				"foo":   1}}}
+	result := g(t, graphql.Params{
+		Schema:        enumTypeTestSchema,
+		RequestString: query,
+	})
+	if !reflect.DeepEqual(expected, result) {
+		t.Fatalf("Unexpected result, Diff: %v", testutil.Diff(expected, result))
+	}
+}

examples/context/main.go

@@ -1,13 +1,13 @@
 package main
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"log"
 	"net/http"
 
 	"github.com/graphql-go/graphql"
-	"golang.org/x/net/context"
 )
 
 var Schema graphql.Schema
@@ -46,7 +46,7 @@ func graphqlHandler(w http.ResponseWriter, r *http.Request) {
 	}{1, "cool user"}
 	result := graphql.Do(graphql.Params{
 		Schema:        Schema,
-		RequestString: r.URL.Query()["query"][0],
+		RequestString: r.URL.Query().Get("query"),
 		Context:       context.WithValue(context.Background(), "currentUser", user),
 	})
 	if len(result.Errors) > 0 {

examples/http/main.go

@@ -88,7 +88,7 @@ func main() {
 	_ = importJSONDataFromFile("data.json", &data)
 
 	http.HandleFunc("/graphql", func(w http.ResponseWriter, r *http.Request) {
-		result := executeQuery(r.URL.Query()["query"][0], schema)
+		result := executeQuery(r.URL.Query().Get("query"), schema)
 		json.NewEncoder(w).Encode(result)
 	})
 

examples/httpdynamic/main.go

@@ -127,7 +127,7 @@ func main() {
 	}
 
 	http.HandleFunc("/graphql", func(w http.ResponseWriter, r *http.Request) {
-		result := executeQuery(r.URL.Query()["query"][0], schema)
+		result := executeQuery(r.URL.Query().Get("query"), schema)
 		json.NewEncoder(w).Encode(result)
 	})