graphql

package module
Version: v0.0.0-...-dcd44e0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 26, 2017 License: BSD-2-Clause Imports: 14 Imported by: 0

README

graphql-go

Sourcegraph Build Status GoDoc

Status

The project is under heavy development. It is stable enough so we use it in production at Sourcegraph, but expect changes.

Goals

  • full support of GraphQL spec (October 2016)
  • minimal API
  • support for context.Context and OpenTracing
  • early error detection at application startup by type-checking if the given resolver matches the schema
  • resolvers are purely based on method sets (e.g. it's up to you if you want to resolve a GraphQL interface with a Go interface or a Go struct)
  • nice error messages (no internal panics, even with an invalid schema or resolver; please file a bug if you see an internal panic)
  • panic handling (a panic in a resolver should not take down the whole app)
  • parallel execution of resolvers

(Some) Documentation

Resolvers

A resolver must have one method for each field of the GraphQL type it resolves. The method name has to be exported and match the field's name in a non-case-sensitive way.

The method has up to two arguments:

  • Optional context.Context argument.
  • Mandatory *struct { ... } argument if the corresponding GraphQL field has arguments. The names of the struct fields have to be exported and have to match the names of the GraphQL arguments in a non-case-sensitive way.

The method has up to two results:

  • The GraphQL field's value as determined by the resolver.
  • Optional error result.

Example for a simple resolver method:

func (r *helloWorldResolver) Hello() string {
	return "Hello world!"
}

The following signature is also allowed:

func (r *helloWorldResolver) Hello(ctx context.Context) (string, error) {
	return "Hello world!", nil
}
OpenTracing

OpenTracing spans are automatically created for each field of the GraphQL query. Fields are marked as trivial if they have no context.Context argument, no field arguments and no error result. You can use this to avoid unnecessary clutter in the trace:

type trivialFieldsFilter struct {
	rec basictracer.SpanRecorder
}

func (f *trivialFieldsFilter) RecordSpan(span basictracer.RawSpan) {
	if b, ok := span.Tags[graphql.OpenTracingTagTrivial].(bool); ok && b {
		return
	}
	f.rec.RecordSpan(span)
}

Documentation

Index

Constants

View Source
const OpenTracingTagArgsPrefix = "graphql.args."
View Source
const OpenTracingTagError = "graphql.error"
View Source
const OpenTracingTagField = "graphql.field"
View Source
const OpenTracingTagOperationName = "graphql.operationName"
View Source
const OpenTracingTagQuery = "graphql.query"
View Source
const OpenTracingTagTrivial = "graphql.trivial"
View Source
const OpenTracingTagType = "graphql.type"
View Source
const OpenTracingTagVariables = "graphql.variables"

Variables

This section is empty.

Functions

func RunTest

func RunTest(t *testing.T, test *Test)

func RunTests

func RunTests(t *testing.T, tests []*Test)

Types

type ID

type ID string

func (ID) ImplementsGraphQLType

func (_ ID) ImplementsGraphQLType(name string) bool

func (*ID) UnmarshalGraphQL

func (id *ID) UnmarshalGraphQL(input interface{}) error

type Response

type Response struct {
	Data       interface{}            `json:"data,omitempty"`
	Errors     []*errors.QueryError   `json:"errors,omitempty"`
	Extensions map[string]interface{} `json:"extensions,omitempty"`
}

type Schema

type Schema struct {

	// MaxParallelism specifies the maximum number of resolvers per request allowed to run in parallel. The default is 10.
	MaxParallelism int
	// contains filtered or unexported fields
}

func MustParseSchema

func MustParseSchema(schemaString string, resolver interface{}) *Schema

func ParseSchema

func ParseSchema(schemaString string, resolver interface{}) (*Schema, error)

func (*Schema) Exec

func (s *Schema) Exec(ctx context.Context, queryString string, operationName string, variables map[string]interface{}) *Response

func (*Schema) Inspect

func (s *Schema) Inspect() *introspection.Schema

func (*Schema) ToJSON

func (s *Schema) ToJSON() ([]byte, error)

type Test

type Test struct {
	Schema         *Schema
	Query          string
	OperationName  string
	Variables      map[string]interface{}
	ExpectedResult string
}

type Time

type Time struct {
	time.Time
}

func (Time) ImplementsGraphQLType

func (_ Time) ImplementsGraphQLType(name string) bool

func (*Time) UnmarshalGraphQL

func (t *Time) UnmarshalGraphQL(input interface{}) error

Directories

Path Synopsis
example
starwars
Package starwars provides a example schema and resolver based on Star Wars characters.
Package starwars provides a example schema and resolver based on Star Wars characters.
internal

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
t or T : Toggle theme light dark auto
y or Y : Canonical URL