Merge branch 'master' into fix-panic-blockstring

Author: chris-ramon

executor.go

@@ -36,7 +36,7 @@ func Execute(p ExecuteParams) (result *Result) {
 	go func(out chan<- *Result, done <-chan struct{}) {
 		defer func() {
 			if err := recover(); err != nil {
-				result.Errors = append(result.Errors, gqlerrors.FormatError(err.(error)))
+				result.AppendErrors(gqlerrors.FormatError(err.(error)))
 			}
 			select {
 			case out <- result:
@@ -54,7 +54,7 @@ func Execute(p ExecuteParams) (result *Result) {
 		})
 
 		if err != nil {
-			result.Errors = append(result.Errors, gqlerrors.FormatError(err))
+			result.AppendErrors(gqlerrors.FormatError(err))
 			return
 		}
 
@@ -67,7 +67,7 @@ func Execute(p ExecuteParams) (result *Result) {
 
 	select {
 	case <-ctx.Done():
-		result.Errors = append(result.Errors, gqlerrors.FormatError(ctx.Err()))
+		result.AppendErrors(gqlerrors.FormatError(ctx.Err()))
 	case r := <-resultChannel:
 		result = r
 	}
@@ -175,15 +175,15 @@ func executeOperation(p executeOperationParams) *Result {
 // Extracts the root type of the operation from the schema.
 func getOperationRootType(schema Schema, operation ast.Definition) (*Object, error) {
 	if operation == nil {
-		return nil, errors.New("Can only execute queries and mutations")
+		return nil, errors.New("Can only execute queries, mutations and subscription")
 	}
 
 	switch operation.GetOperation() {
 	case ast.OperationTypeQuery:
 		return schema.QueryType(), nil
 	case ast.OperationTypeMutation:
 		mutationType := schema.MutationType()
-		if mutationType.PrivateName == "" {
+		if mutationType == nil || mutationType.PrivateName == "" {
 			return nil, gqlerrors.NewError(
 				"Schema is not configured for mutations",
 				[]ast.Node{operation},
@@ -196,7 +196,7 @@ func getOperationRootType(schema Schema, operation ast.Definition) (*Object, err
 		return mutationType, nil
 	case ast.OperationTypeSubscription:
 		subscriptionType := schema.SubscriptionType()
-		if subscriptionType.PrivateName == "" {
+		if subscriptionType == nil || subscriptionType.PrivateName == "" {
 			return nil, gqlerrors.NewError(
 				"Schema is not configured for subscriptions",
 				[]ast.Node{operation},
@@ -964,6 +964,22 @@ func DefaultResolveFn(p ResolveParams) (interface{}, error) {
 		return property, nil
 	}
 
+	// Try accessing as map via reflection
+	if r := reflect.ValueOf(p.Source); r.Kind() == reflect.Map && r.Type().Key().Kind() == reflect.String {
+		val := r.MapIndex(reflect.ValueOf(p.Info.FieldName))
+		if val.IsValid() {
+			property := val.Interface()
+			if val.Type().Kind() == reflect.Func {
+				// try type casting the func to the most basic func signature
+				// for more complex signatures, user have to define ResolveFn
+				if propertyFn, ok := property.(func() interface{}); ok {
+					return propertyFn(), nil
+				}
+			}
+			return property, nil
+		}
+	}
+
 	// last resort, return nil
 	return nil, nil
 }

executor_test.go

@@ -297,6 +297,62 @@ func TestMergesParallelFragments(t *testing.T) {
 	}
 }
 
+type CustomMap map[string]interface{}
+
+func TestCustomMapType(t *testing.T) {
+	query := `
+		query Example { data { a } }
+	`
+	data := CustomMap{
+		"a": "1",
+		"b": "2",
+	}
+	schema, err := graphql.NewSchema(graphql.SchemaConfig{
+		Query: graphql.NewObject(graphql.ObjectConfig{
+			Name: "RootQuery",
+			Fields: graphql.Fields{
+				"data": &graphql.Field{
+					Type: graphql.NewObject(graphql.ObjectConfig{
+						Name: "Data",
+						Fields: graphql.Fields{
+							"a": &graphql.Field{
+								Type: graphql.String,
+							},
+							"b": &graphql.Field{
+								Type: graphql.String,
+							},
+						},
+					}),
+					Resolve: func(p graphql.ResolveParams) (interface{}, error) {
+						return data, nil
+					},
+				},
+			},
+		}),
+	})
+	if err != nil {
+		t.Fatalf("Error in schema %v", err.Error())
+	}
+
+	result := testutil.TestExecute(t, graphql.ExecuteParams{
+		Schema: schema,
+		Root:   data,
+		AST:    testutil.TestParse(t, query),
+	})
+	if len(result.Errors) > 0 {
+		t.Fatalf("wrong result, unexpected errors: %v", result.Errors)
+	}
+
+	expected := map[string]interface{}{
+		"data": map[string]interface{}{
+			"a": "1",
+		},
+	}
+	if !reflect.DeepEqual(result.Data, expected) {
+		t.Fatalf("Expected context.key to equal %v, got %v", expected, result.Data)
+	}
+}
+
 func TestThreadsSourceCorrectly(t *testing.T) {
 
 	query := `
@@ -843,6 +899,57 @@ func TestThrowsIfUnknownOperationNameIsProvided(t *testing.T) {
 		t.Fatalf("unexpected result, Diff: %v", testutil.Diff(expectedErrors, result.Errors))
 	}
 }
+
+func TestThrowsIfOperationTypeIsUnsupported(t *testing.T) {
+	query := `mutation Mut { a } subscription Sub { a }`
+	operations := []string{"Mut", "Sub"}
+
+	expectedErrors := [][]gqlerrors.FormattedError{
+		{{
+			Message:   `Schema is not configured for mutations`,
+			Locations: []location.SourceLocation{{Line: 1, Column: 1}},
+		}},
+		{{
+			Message:   `Schema is not configured for subscriptions`,
+			Locations: []location.SourceLocation{{Line: 1, Column: 20}},
+		}},
+	}
+
+	schema, err := graphql.NewSchema(graphql.SchemaConfig{
+		Query: graphql.NewObject(graphql.ObjectConfig{
+			Name: "Query",
+			Fields: graphql.Fields{
+				"a": &graphql.Field{
+					Type: graphql.String,
+				},
+			},
+		}),
+	})
+	if err != nil {
+		t.Fatalf("Error in schema %v", err.Error())
+	}
+
+	// parse query
+	ast := testutil.TestParse(t, query)
+
+	for opIndex, operation := range operations {
+		expectedErrors := expectedErrors[opIndex]
+
+		// execute
+		ep := graphql.ExecuteParams{
+			Schema:        schema,
+			AST:           ast,
+			OperationName: operation,
+		}
+		result := testutil.TestExecute(t, ep)
+		if result.Data != nil {
+			t.Fatalf("wrong result, expected nil result.Data, got %v", result.Data)
+		}
+		if !testutil.EqualFormattedErrors(expectedErrors, result.Errors) {
+			t.Fatalf("unexpected result, Diff: %v", testutil.Diff(expectedErrors, result.Errors))
+		}
+	}
+}
 func TestUsesTheQuerySchemaForQueries(t *testing.T) {
 
 	doc := `query Q { a } mutation M { c } subscription S { a }`