README
¶
graphql-go
Changes in this fork
- Support exposing the selected fields in a resolver, commit 5472fce1, see graph-gophers/graphql-go#169
- Replace fmt.Errorf and errors.New with pkg/errors, commit 0c4918ae, see graph-gophers/graphql-go#189
- Support wrapped type for
[]query.SelectedFieldas resolver argument, commit d95424a7, improves on graph-gophers/graphql-go#169 - Do not print panic value in errors but store it as a transient field, commit 2e0e8590
- Always store the original error, commit 8ebe5b04
Status
Update: March 1, 2018
This project has transferred ownership from github.com/neelance/graphql-go to
github.com/qdentity/graphql-go, which will enable us to maintain and evolve the
library @neelance created, and let him focus on WebAssembly / Go development.
I'm super grateful to @neelance for all his work blazing the trail
with graphql-go, and I'm ecstatic to work with the community to continue
improving this library.
I'm going to help address issues, review and merge changes, and continue development with the same ethos as we started.
The immediate goal remains—full support of the GraphQL specification.
- Tony (@tonyghita)
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)
- propagation of
nullon resolver errors - everything else
- propagation of
- 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)
- nice errors on resolver validation
- nice errors on all invalid schemas
- nice errors on all invalid queries
- 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.Contextargument. - 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. - Optional
[]query.SelectedFieldargument to receive the tree of selected subfields in the GraphQL query (useful for preloading of database relations)
The method has up to two results:
- The GraphQL field's value as determined by the resolver.
- Optional
errorresult.
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
}
Community Examples
deltaskelta/graphql-go-pets-example - graphql-go resolving against a sqlite database
OscarYuen/go-graphql-starter - a starter application integrated with dataloader, psql and basic authenication
Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type ID ¶
type ID string
ID represents GraphQL's "ID" scalar type. A custom type may be used instead.
func (ID) ImplementsGraphQLType ¶
func (ID) MarshalJSON ¶
func (*ID) UnmarshalGraphQL ¶
type Response ¶
type Response struct {
Data json.RawMessage `json:"data,omitempty"`
Errors []*errors.QueryError `json:"errors,omitempty"`
Extensions map[string]interface{} `json:"extensions,omitempty"`
}
Response represents a typical response of a GraphQL server. It may be encoded to JSON directly or it may be further processed to a custom response type, for example to include custom error data.
type Schema ¶
type Schema struct {
// contains filtered or unexported fields
}
Schema represents a GraphQL schema with an optional resolver.
func MustParseSchema ¶
MustParseSchema calls ParseSchema and panics on error.
func ParseSchema ¶
ParseSchema parses a GraphQL schema and attaches the given root resolver. It returns an error if the Go type signature of the resolvers does not match the schema. If nil is passed as the resolver, then the schema can not be executed, but it may be inspected (e.g. with ToJSON).
func (*Schema) Exec ¶
func (s *Schema) Exec(ctx context.Context, queryString string, operationName string, variables map[string]interface{}) *Response
Exec executes the given query with the schema's resolver. It panics if the schema was created without a resolver. If the context get cancelled, no further resolvers will be called and a the context error will be returned as soon as possible (not immediately).
func (*Schema) Inspect ¶
func (s *Schema) Inspect() *introspection.Schema
Inspect allows inspection of the given schema.
type SchemaOpt ¶
type SchemaOpt func(*Schema)
SchemaOpt is an option to pass to ParseSchema or MustParseSchema.
func Logger ¶
Logger is used to log panics durring query execution. It defaults to exec.DefaultLogger.
func MaxParallelism ¶
MaxParallelism specifies the maximum number of resolvers per request allowed to run in parallel. The default is 10.
type Time ¶
Time is a custom GraphQL type to represent an instant in time. It has to be added to a schema via "scalar Time" since it is not a predeclared GraphQL type like "ID".
Source Files
Directories