GraphQL

Code

Many different programming languages support GraphQL. This list contains some of the more popular server-side frameworks, client libraries, services, and other useful stuff.

Server Libraries #

In addition to the GraphQL reference implementations in JavaScript, server libraries include:

C# / .NET #

Clojure #

alumbra#

A set of reusable GraphQL components for Clojure conforming to the data structures given in alumbra.spec.

(require '[alumbra.core :as alumbra] '[claro.data :as data])(def schema "type Person { name: String!, friends:[Person!]!} type QueryRoot {person(id: ID!): Person, me: Person!} schema { query: QueryRoot }")(defrecord Person [id] data/Resolvable (resolve![_ _]{:name (str "Person #" id):friends (map ->Person (range (inc id)(+ id 3)))}))(def QueryRoot {:person (map->Person {}):me (map->Person {:id 0})})(def app (alumbra/handler {:schema schema :query QueryRoot}))(defonce my-graphql-server (aleph.http/start-server #'app {:port 3000}))
$ curl -XPOST "http://0:3000"-H'Content-Type: application/json'-d'{"query":"{ me { name, friends { name } } }"}' {"data":{"me":{"name":"Person #0","friends":[{"name":"Person #1"},{"name":"Person #2"}]}}}

graphql-clj#

A Clojure library that provides a GraphQL implementation.

Code that executes a hello world GraphQL query with graphql-clj:

(def schema "type QueryRoot { hello: String }")(defn resolver-fn [type-name field-name](get-in{"QueryRoot"{"hello"(fn [context parent & rest]"Hello world!")}}[type-name field-name]))(require '[graphql-clj.executor :as executor])(executor/execute nil schema resolver-fn "{ hello }")

lacinia#

A full implementation of the GraphQL specification that aims to maintain external compliance with the specification.

Elixir #

Erlang #

Go #

Groovy #

gorm-graphql#

Core Library - The GORM GraphQL library provides functionality to generate a GraphQL schema based on your GORM entities. In addition to mapping domain classes to a GraphQL schema, the core library also provides default implementations of "data fetchers" to query, update, and delete data through executions of the schema.

Grails Plugin - In a addition to the Core Library, the GORM GraphQL Grails Plugin:

  • Provides a controller to receive and respond to GraphQL requests through HTTP, based on their guidelines.
  • Generates the schema at startup with spring bean configuration to make it easy to extend.
  • Includes a GraphiQL browser enabled by default in development. The browser is accessible at /graphql/browser.
  • Overrides the default data binder to use the data binding provided by Grails
  • Provides a trait to make integration testing of your GraphQL endpoints easier

See the documentation for more information.

GQL#

GQL is a Groovy library for GraphQL

Java #

graphql-java#

A Java library for building GraphQL APIs.

Code that executes a hello world GraphQL query with graphql-java:

import graphql.ExecutionResult;import graphql.GraphQL;import graphql.schema.GraphQLSchema;import graphql.schema.StaticDataFetcher;import graphql.schema.idl.RuntimeWiring;import graphql.schema.idl.SchemaGenerator;import graphql.schema.idl.SchemaParser;import graphql.schema.idl.TypeDefinitionRegistry;importstatic graphql.schema.idl.RuntimeWiring.newRuntimeWiring;publicclassHelloWorld{publicstaticvoidmain(String[] args){ String schema ="type Query{hello: String} schema{query: Query}"; SchemaParser schemaParser =newSchemaParser(); TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema); RuntimeWiring runtimeWiring =newRuntimeWiring().type("Query", builder -> builder.dataFetcher("hello",newStaticDataFetcher("world"))).build(); SchemaGenerator schemaGenerator =newSchemaGenerator(); GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring); GraphQL build = GraphQL.newGraphQL(graphQLSchema).build(); ExecutionResult executionResult = build.execute("{hello}"); System.out.println(executionResult.getData().toString());// Prints: {hello=world}}}

See the graphql-java docs for more information on setup.

JavaScript #

GraphQL.js (github) (npm) #

The reference implementation of the GraphQL specification, designed for running GraphQL in a Node.js environment.

To run a GraphQL.js hello world script from the command line:

npm install graphql

Then run node hello.js with this code in hello.js:

var{ graphql, buildSchema }=require('graphql');var schema =buildSchema(` type Query { hello: String } `);var root ={ hello:()=>'Hello world!'};graphql(schema,'{ hello }', root).then((response)=>{ console.log(response);});

express-graphql (github) (npm) #

The reference implementation of a GraphQL API server over an Express webserver. You can use this to run GraphQL in conjunction with a regular Express webserver, or as a standalone GraphQL server.

To run an express-graphql hello world server:

npm install express express-graphql graphql

Then run node server.js with this code in server.js:

var express =require('express');var graphqlHTTP =require('express-graphql');var{ buildSchema }=require('graphql');var schema =buildSchema(` type Query { hello: String } `);var root ={ hello:()=>'Hello world!'};var app =express(); app.use('/graphql',graphqlHTTP({ schema: schema, rootValue: root, graphiql:true,})); app.listen(4000,()=> console.log('Now browse to localhost:4000/graphql'));

apollo-server (github) (npm) #

A set of GraphQL server packages from Apollo that work with various Node.js HTTP frameworks (Express, Connect, Hapi, Koa etc).

To run a hello world server with apollo-server-express:

npm install apollo-server-express body-parser express graphql graphql-tools

Then run node server.js with this code in server.js:

var express =require('express');var bodyParser =require('body-parser');var{ graphqlExpress, graphiqlExpress }=require('apollo-server-express');var{ makeExecutableSchema }=require('graphql-tools');var typeDefs =[` type Query { hello: String } schema { query: Query }`];var resolvers ={ Query:{hello(root){return'world';}}};var schema =makeExecutableSchema({typeDefs, resolvers});var app =express(); app.use('/graphql', bodyParser.json(),graphqlExpress({schema})); app.use('/graphiql',graphiqlExpress({endpointURL:'/graphql'})); app.listen(4000,()=> console.log('Now browse to localhost:4000/graphiql'));

Apollo Server also supports all Node.js HTTP server frameworks: Express, Connect, HAPI and Koa.

PHP #

  • graphql-php: A PHP port of GraphQL reference implementation
  • graphql-relay-php: A library to help construct a graphql-php server supporting react-relay.

Siler (github) #

Siler is a PHP library powered with high-level abstractions to work with GraphQL.

To run a Siler hello world script:

type Query {hello:String}
<?php declare(strict_types=1); require_once '/path/to/vendor/autoload.php'; use SilerDiactoros; use SilerGraphql; use SilerHttp; $typeDefs =file_get_contents(__DIR__.'/schema.graphql'); $resolvers =['Query'=>['hello'=>'world',],]; $schema =Graphqlschema($typeDefs, $resolvers); echo "Server running at http://127.0.0.1:8080";Httpserver(Graphqlpsr7($schema),function(Throwable $err){var_dump($err);returnDiactorosjson(['error'=>true,'message'=> $err->getMessage(),]);})()->run();

It also provides functionality for the construction of a WebSocket Subscriptions Server based on how Apollo works.

Python #

Graphene (github) #

A Python library for building GraphQL APIs.

To run a Graphene hello world script:

pip install graphene

Then run python hello.py with this code in hello.py:

import graphene classQuery(graphene.ObjectType): hello = graphene.String(name=graphene.String(default_value="World")) def resolve_hello(self, info, name):return'Hello '+ name schema = graphene.Schema(query=Query) result = schema.execute('{ hello }')print(result.data['hello']) # "Hello World"

There are also nice bindings for Relay, Django, SQLAlchemy, and Google App Engine.

Ruby #

graphql-ruby#

A Ruby library for building GraphQL APIs.

To run a hello world script with graphql-ruby:

gem install graphql

Then run ruby hello.rb with this code in hello.rb:

require 'graphql' QueryType = GraphQL::ObjectType.define do name 'Query' field :hello do type types.String resolve ->(obj, args, ctx){'Hello world!'} end end Schema = GraphQL::Schema.define do query QueryType end puts Schema.execute('{ hello }').to_json

There are also nice bindings for Relay and Rails.

Scala #

Sangria (github): A Scala GraphQL library that supports Relay. #

An example of a hello world GraphQL schema and query with sangria:

import sangria.schema._ import sangria.execution._ import sangria.macros._ val QueryType =ObjectType("Query", fields[Unit, Unit](Field("hello", StringType, resolve = _ ⇒ "Hello world!"))) val schema =Schema(QueryType) val query = graphql"{ hello }" Executor.execute(schema, query) map println

GraphQL Clients #

C# / .NET #

Clojurescript #

  • re-graph: A GraphQL client implemented in Clojurescript with support for websockets.

Go #

  • graphql: A GraphQL client implementation in Go.

Java / Android #

  • Apollo Android: A strongly-typed, caching GraphQL client for Android, written in Java.

  • Nodes: A GraphQL JVM Client designed for constructing queries from standard model definitions. By American Express.

JavaScript #

  • Relay (github) (npm): Facebook's framework for building React applications that talk to a GraphQL backend.
  • Apollo Client (github): A powerful JavaScript GraphQL client, designed to work well with React, React Native, Angular 2, or just plain JavaScript.
  • graphql-request: A simple and flexible JavaScript GraphQL client that works in all JavaScript environments (the browser, Node.js, and React Native) - basically a lightweight wrapper around fetch.
  • Lokka: A simple JavaScript GraphQL client that works in all JavaScript environments (the browser, Node.js, and React Native).
  • nanogql: Tiny GraphQL client library using template strings.
  • gq-loader: A simple JavaScript GraphQL client,Let the *.gql file be used as a module through webpack loader.
  • AWS Amplify: A JavaScript library for application development using cloud services, which supports GraphQL backend and React components for working with GraphQL data.
  • Grafoo: An all purpose GraphQL client with view layer integrations for multiple frameworks in just 1.6kb.

Swift / Objective-C iOS #

  • Apollo iOS (github): A GraphQL client for iOS that returns results as query-specific Swift types, and integrates with Xcode to show your Swift source and GraphQL side by side, with inline validation errors.
  • GraphQL iOS: An Objective-C GraphQL client for iOS.

Python #

  • GQL: A GraphQL client in Python.
  • python-graphql-client: Simple GraphQL client for Python 2.7+.
  • sgqlc: A simple Python GraphQL client. Supports generating code generation for types defined in a GraphQL schema.

Tools #

  • graphiql (npm): An interactive in-browser GraphQL IDE.
  • libgraphqlparser: A GraphQL query language parser in C++ with C and C++ APIs.
  • Graphql Language Service: An interface for building GraphQL language services for IDEs (diagnostics, autocomplete etc).
  • quicktype (github): Generate types for GraphQL queries in TypeScript, Swift, golang, C#, C++, and more.

Services #

  • Apollo Engine: A service for monitoring the performance and usage of your GraphQL backend.
  • GraphCMS: A BaaS (Backend as a Service) that sets you up with a GraphQL backend as well as tools for content editors to work with the stored data.
  • Graphcool (github): A BaaS (Backend as a Service) providing a GraphQL backend for your applications with a powerful web ui for managing your database and stored data.
  • Reindex (github): A BaaS (Backend as a Service) that sets you up with a GraphQL backend targeted at applications using React and Relay.
  • Scaphold (github): A BaaS (Backend as a Service) that sets you up with a GraphQL backend for your applications with many different integrations.
  • Tipe (github): A SaaS (Software as a Service) content management system that allows you to create your content with powerful editing tools and access it from anywhere with a GraphQL or REST API.
  • AWS AppSync: Fully managed GraphQL service with realtime subscriptions, offline programming & synchronization, and enterprise security features as well as fine grained authorization controls.
  • Hasura: A BaaS (Backend as a Service) that lets you create tables, define permissions on Postgres and query and manipulate using a GraphQL interface.

More Stuff #

  • awesome-graphql: A fantastic community maintained collection of libraries, resources, and more.