graph-gophers · May 17, 2018 · May 17, 2018 · May 17, 2018 · May 17, 2018 · May 17, 2018
Showing with 186 additions and 16 deletions.

+44 −0 fields/fields.go

+4 −0 internal/exec/exec.go

+26 −16 internal/exec/resolvable/resolvable.go

+63 −0 relay/relay.go

+49 −0 relay/relay_test.go
diff --git a/fields/fields.go b/fields/fields.go
@@ -0,0 +1,44 @@
+package fields
+
+import (
+	"strings"
+)
+
+type Checker interface {
+	ProvidedFields()  map[string]interface{}
+	FieldProvided(string) bool
+}
+
+type ArgsChecker struct {
+	Args map[string]interface{}
+}
+
+func (n *ArgsChecker) ProvidedFields() map[string]interface{} {
+	return n.Args
+}
+
+func (n *ArgsChecker) FieldProvided(field string) bool {
+	path := strings.Split(field, ".")
+	return step(n.Args, path)
+}
+
+func untitle(s string) string {
+	return strings.Join([]string{
+		strings.ToLower(s[:1]),
+		s[1:],
+	}, "")
+}
+
+func step(args map[string]interface{}, path []string) bool {
+	if val, ok := args[untitle(path[0])]; ok {
+		if len(path) == 1 {
+			return true
+		}
+		if v, ok := val.(map[string]interface{}); ok {
+			return step(v, path[1:])
+		}
+
+		return true
+	}
+	return false
+}
diff --git a/internal/exec/exec.go b/internal/exec/exec.go
@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/graph-gophers/graphql-go/errors"
+	"github.com/graph-gophers/graphql-go/fields"
 	"github.com/graph-gophers/graphql-go/internal/common"
 	"github.com/graph-gophers/graphql-go/internal/exec/resolvable"
 	"github.com/graph-gophers/graphql-go/internal/exec/selected"
@@ -207,6 +208,9 @@ func execFieldSelection(ctx context.Context, r *Request, s *resolvable.Schema, f
 			if f.field.ArgsPacker != nil {
 				in = append(in, f.field.PackedArgs)
 			}
+			if f.field.HasFieldChecker {
+				in = append(in, reflect.ValueOf(&fields.ArgsChecker{Args: f.field.Args}))
+			}
 			callOut := res.Method(f.field.MethodIndex).Call(in)
 			result = callOut[0]
 			if f.field.HasError && !callOut[1].IsNil() {

diff --git a/internal/exec/resolvable/resolvable.go b/internal/exec/resolvable/resolvable.go
@@ -6,6 +6,7 @@ import (
 	"reflect"
 	"strings"
 
+	"github.com/graph-gophers/graphql-go/fields"
 	"github.com/graph-gophers/graphql-go/internal/common"
 	"github.com/graph-gophers/graphql-go/internal/exec/packer"
 	"github.com/graph-gophers/graphql-go/internal/schema"
@@ -32,14 +33,15 @@ type Object struct {
 
 type Field struct {
 	schema.Field
-	TypeName    string
-	MethodIndex int
-	FieldIndex  []int
-	HasContext  bool
-	HasError    bool
-	ArgsPacker  *packer.StructPacker
-	ValueExec   Resolvable
-	TraceLabel  string
+	TypeName        string
+	MethodIndex     int
+	FieldIndex      []int
+	HasContext      bool
+	HasFieldChecker bool
+	HasError        bool
+	ArgsPacker      *packer.StructPacker
+	ValueExec       Resolvable
+	TraceLabel      string
 }
 
 func (f *Field) UseMethodResolver() bool {
@@ -292,13 +294,15 @@ func (b *execBuilder) makeObjectExec(typeName string, fields schema.FieldList, p
 
 var contextType = reflect.TypeOf((*context.Context)(nil)).Elem()
 var errorType = reflect.TypeOf((*error)(nil)).Elem()
+var checkerType = reflect.TypeOf((*fields.Checker)(nil)).Elem()
 
 func (b *execBuilder) makeFieldExec(typeName string, f *schema.Field, m reflect.Method, sf reflect.StructField,
 	methodIndex int, fieldIndex []int, methodHasReceiver bool) (*Field, error) {
 
 	var argsPacker *packer.StructPacker
 	var hasError bool
 	var hasContext bool
+	var hasFieldChecker bool
 
 	// Validate resolver method only when there is one
 	if methodIndex != -1 {
@@ -327,6 +331,11 @@ func (b *execBuilder) makeFieldExec(typeName string, f *schema.Field, m reflect.
 			in = in[1:]
 		}
 
+		hasFieldChecker = len(in) > 0 && in[0] == checkerType
+		if hasFieldChecker {
+			in = in[1:]
+		}
+
 		if len(in) > 0 {
 			return nil, fmt.Errorf("too many parameters")
 		}
@@ -349,14 +358,15 @@ func (b *execBuilder) makeFieldExec(typeName string, f *schema.Field, m reflect.
 	}
 
 	fe := &Field{
-		Field:       *f,
-		TypeName:    typeName,
-		MethodIndex: methodIndex,
-		FieldIndex:  fieldIndex,
-		HasContext:  hasContext,
-		ArgsPacker:  argsPacker,
-		HasError:    hasError,
-		TraceLabel:  fmt.Sprintf("GraphQL field: %s.%s", typeName, f.Name),
+		Field:           *f,
+		TypeName:        typeName,
+		MethodIndex:     methodIndex,
+		FieldIndex:      fieldIndex,
+		HasContext:      hasContext,
+		HasFieldChecker: hasFieldChecker,
+		ArgsPacker:      argsPacker,
+		HasError:        hasError,
+		TraceLabel:      fmt.Sprintf("GraphQL field: %s.%s", typeName, f.Name),
 	}
 
 	var out reflect.Type

diff --git a/relay/relay.go b/relay/relay.go
@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io/ioutil"
 	"net/http"
 	"strings"
 
@@ -47,6 +48,68 @@ type Handler struct {
 	Schema *graphql.Schema
 }
 
+type BatchedHandler struct {
+	Schema             *graphql.Schema
+	MaxParallelQueries int
+}
+
+type RequestData struct {
+	ID            string
+	Query         string                 `json:"query"`
+	Variables     map[string]interface{} `json:"variables"`
+	OperationName string                 `json:"operationName"`
+}
+
+type BatchedResponse struct {
+	ID string `json:"id"`
+	graphql.Response
+}
+
+func (h *BatchedHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	queryBytes, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	var responses []*BatchedResponse
+	var queries []*RequestData
+	err = json.Unmarshal(queryBytes, &queries)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	responsesChan := make(chan *BatchedResponse, len(queries))
+	semaphore := make(chan struct{}, h.MaxParallelQueries)
+	for i := range queries {
+		qr := queries[i]
+		go func(query *RequestData, responsesChan chan *BatchedResponse) {
+			if h.MaxParallelQueries > 0 {
+				semaphore <- struct{}{}
+				defer func() { <-semaphore }()
+			}
+
+			gqlResponse := h.Schema.Exec(r.Context(), query.Query, query.OperationName, query.Variables)
+			responsesChan <- &BatchedResponse{query.ID, *gqlResponse}
+		}(qr, responsesChan)
+	}
+
+	for i := 0; i < len(queries); i++ {
+		responses = append(responses, <-responsesChan)
+	}
+	close(responsesChan)
+
+	responseJSON, err := json.Marshal(responses)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.Write(responseJSON)
+}
+
 func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	var params struct {
 		Query         string                 `json:"query"`

diff --git a/relay/relay_test.go b/relay/relay_test.go
@@ -34,3 +34,52 @@ func TestServeHTTP(t *testing.T) {
 		t.Fatalf("Invalid response. Expected [%s], but instead got [%s]", expectedResponse, actualResponse)
 	}
 }
+
+func TestBatchedServeHTTP(t *testing.T) {
+	t.Run("no parallel queries limit", func(t *testing.T) {
+		w := httptest.NewRecorder()
+		r := httptest.NewRequest("POST", "/some/path/here", strings.NewReader(`[{"id":"qID", "query":"{ hero { name } }", "operationName":"", "variables": null},
+	{"id":"qID", "query":"{ hero { name } }", "operationName":"", "variables": null}]`))
+		h := relay.BatchedHandler{Schema: starwarsSchema}
+
+		h.ServeHTTP(w, r)
+
+		if w.Code != 200 {
+			t.Fatalf("Expected status code 200, got %d.", w.Code)
+		}
+
+		contentType := w.Header().Get("Content-Type")
+		if contentType != "application/json" {
+			t.Fatalf("Invalid content-type. Expected [application/json], but instead got [%s]", contentType)
+		}
+
+		expectedResponse := `[{"id":"qID","data":{"hero":{"name":"R2-D2"}}},{"id":"qID","data":{"hero":{"name":"R2-D2"}}}]`
+		actualResponse := w.Body.String()
+		if expectedResponse != actualResponse {
+			t.Fatalf("Invalid response. Expected [%s], but instead got [%s]", expectedResponse, actualResponse)
+		}
+	})
+	t.Run("with parallel queries limit", func(t *testing.T) {
+		w := httptest.NewRecorder()
+		r := httptest.NewRequest("POST", "/some/path/here", strings.NewReader(`[{"id":"qID", "query":"{ hero { name } }", "operationName":"", "variables": null},
+	{"id":"qID", "query":"{ hero { name } }", "operationName":"", "variables": null}]`))
+		h := relay.BatchedHandler{Schema: starwarsSchema, MaxParallelQueries: 1}
+
+		h.ServeHTTP(w, r)
+
+		if w.Code != 200 {
+			t.Fatalf("Expected status code 200, got %d.", w.Code)
+		}
+
+		contentType := w.Header().Get("Content-Type")
+		if contentType != "application/json" {
+			t.Fatalf("Invalid content-type. Expected [application/json], but instead got [%s]", contentType)
+		}
+
+		expectedResponse := `[{"id":"qID","data":{"hero":{"name":"R2-D2"}}},{"id":"qID","data":{"hero":{"name":"R2-D2"}}}]`
+		actualResponse := w.Body.String()
+		if expectedResponse != actualResponse {
+			t.Fatalf("Invalid response. Expected [%s], but instead got [%s]", expectedResponse, actualResponse)
+		}
+	})
+}