Exemple #1
0
func Do(p Params) *Result {
	source := source.NewSource(&source.Source{
		Body: []byte(p.RequestString),
		Name: "GraphQL request",
	})
	AST, err := parser.Parse(parser.ParseParams{Source: source})
	if err != nil {
		return &Result{
			Errors: gqlerrors.FormatErrors(err),
		}
	}
	validationResult := ValidateDocument(&p.Schema, AST, nil)

	if !validationResult.IsValid {
		return &Result{
			Errors: validationResult.Errors,
		}
	}

	return Execute(ExecuteParams{
		Schema:        p.Schema,
		Root:          p.RootObject,
		AST:           AST,
		OperationName: p.OperationName,
		Args:          p.VariableValues,
		Context:       p.Context,
	})
}
func expectInvalidRule(t *testing.T, schema *graphql.Schema, rules []graphql.ValidationRuleFn, queryString string, expectedErrors []gqlerrors.FormattedError) {
	source := source.NewSource(&source.Source{
		Body: queryString,
	})
	AST, err := parser.Parse(parser.ParseParams{Source: source})
	if err != nil {
		t.Fatal(err)
	}
	result := graphql.ValidateDocument(schema, AST, rules)
	if len(result.Errors) != len(expectedErrors) {
		t.Fatalf("Should have %v errors, got %v", len(expectedErrors), len(result.Errors))
	}
	if result.IsValid != false {
		t.Fatalf("IsValid should be false, got %v", result.IsValid)
	}
	for _, expectedErr := range expectedErrors {
		found := false
		for _, err := range result.Errors {
			if reflect.DeepEqual(expectedErr, err) {
				found = true
				break
			}
		}
		if found == false {
			t.Fatalf("Unexpected result, Diff: %v", Diff(expectedErrors, result.Errors))
		}
	}

}
Exemple #3
0
func parse(t *testing.T, query string) *ast.Document {
	astDoc, err := parser.Parse(parser.ParseParams{
		Source: query,
		Options: parser.ParseOptions{
			NoLocation: true,
		},
	})
	if err != nil {
		t.Fatalf("Parse failed: %v", err)
	}
	return astDoc
}
Exemple #4
0
func TestParse(t *testing.T, query string) *ast.Document {
	astDoc, err := parser.Parse(parser.ParseParams{
		Source: query,
		Options: parser.ParseOptions{
			// include source, for error reporting
			NoSource: false,
		},
	})
	if err != nil {
		t.Fatalf("Parse failed: %v", err)
	}
	return astDoc
}
func expectValidRule(t *testing.T, schema *graphql.Schema, rules []graphql.ValidationRuleFn, queryString string) {
	source := source.NewSource(&source.Source{
		Body: queryString,
	})
	AST, err := parser.Parse(parser.ParseParams{Source: source})
	if err != nil {
		t.Fatal(err)
	}
	result := graphql.ValidateDocument(schema, AST, rules)
	if len(result.Errors) > 0 {
		t.Fatalf("Should validate, got %v", result.Errors)
	}
	if result.IsValid != true {
		t.Fatalf("IsValid should be true, got %v", result.IsValid)
	}

}
Exemple #6
0
func HandleGraphQL(w http.ResponseWriter, r *http.Request) {
	ctx := getContext(r)

	startPath := r.URL.Path[:len(r.URL.Path)-9]
	allow := db.ReadAllowedAt(startPath, ctx.user)
	if !allow {
		json.NewEncoder(w).Encode(GraphQLResponse{
			Errors: []GraphQLError{GraphQLError{"_read permission for this path needed."}},
		})
		return
	}

	var gql string
	switch r.Header.Get("Content-Type") {
	case "application/json":
		jsonBody := struct {
			Query string `json:"query"`
		}{}
		err := json.NewDecoder(r.Body).Decode(&jsonBody)
		if err != nil {
			json.NewEncoder(w).Encode(GraphQLResponse{
				Errors: []GraphQLError{GraphQLError{"failed to parse json: " + err.Error()}},
			})
			return
		}
		gql = jsonBody.Query
		break
	case "application/x-www-form-urlencoded":
		r.ParseForm()
		gql = r.FormValue("query")
		break
	// case "application/graphql":
	default:
		body, err := ioutil.ReadAll(r.Body)
		if err != nil {
			json.NewEncoder(w).Encode(GraphQLResponse{
				Errors: []GraphQLError{GraphQLError{"couldn't read request body."}},
			})
			return
		}
		gql = string(body)
	}

	doc, err := parser.Parse(parser.ParseParams{
		Source:  gql,
		Options: parser.ParseOptions{true, true},
	})
	if err != nil || len(doc.Definitions) != 1 {
		message := "your graphql query must describe a 'query' operation."
		if err != nil {
			message = err.Error()
		}
		json.NewEncoder(w).Encode(GraphQLResponse{
			Errors: []GraphQLError{GraphQLError{"failed to parse gql query: " + message}},
		})
		return
	}

	// we're just ignoring Args for now -- maybe we'll find an utility for them in the future
	topfields := doc.Definitions[0].(*ast.OperationDefinition).SelectionSet.Selections
	response := cmap.New()

	godeepAsyncMultiple(topfields, startPath, &response)

	w.WriteHeader(200)
	w.Header().Add("Content-Type", "application/json")
	json.NewEncoder(w).Encode(GraphQLResponse{
		Data: response.Items(),
	})
}