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#

graphql-dotnet: GraphQL for .NET#

using System;
using GraphQL;
using GraphQL.Types;
 
public class Program
{
  public static void Main(string[] args)
  {
    var schema = Schema.For(@"
      type Query {
        hello: String
      }
    ");
 
    var json = schema.Execute(_ =>
    {
      _.Query = "{ hello }";
      _.Root = new { Hello = "Hello World!" };
    });
 
    Console.WriteLine(json);
  }
}
  • graphql-net: Convert GraphQL to IQueryable
  • Entity GraphQL: .NET Core GraphQL library. Compiles to IQueryable to easily expose a schema from an existing data model (E.g. from an Entity Framework data model)
  • DotNetGraphQLQueryGen: .NET Core library to generate classes from a GraphQL schema for type-safe querying in dotnet
  • Hot Chocolate: GraphQL Server for .NET core and .NET classic

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;
 
import static graphql.schema.idl.RuntimeWiring.newRuntimeWiring;
 
public class HelloWorld {
 
    public static void main(String[] args) {
        String schema = "type Query{hello: String} schema{query: Query}";
 
        SchemaParser schemaParser = new SchemaParser();
        TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema);
 
        RuntimeWiring runtimeWiring = new RuntimeWiring()
                .type("Query", builder -> builder.dataFetcher("hello", new StaticDataFetcher("world")))
                .build();
 
        SchemaGenerator schemaGenerator = new SchemaGenerator();
        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 express

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

const express = require('express');
const { ApolloServer, gql } = require('apollo-server-express');
 
const typeDefs = gql`
  type Query {
    hello: String
  }
`;
 
const resolvers = {
  Query: {
    hello: () => 'Hello world!',
  },
};
 
const server = new ApolloServer({ typeDefs, resolvers });
 
const app = express();
server.applyMiddleware({ app });
 
app.listen({ port: 4000 }, () =>
  console.log('Now browse to http://localhost:4000' + server.graphqlPath)
);

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

Kotlin#

  • graphql-kotlin: A set of libraries for running GraphQL server in Kotlin.

Perl#

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.
  • Railt: A PHP GraphQL Framework.
  • Lighthouse: A GraphQL server for Laravel
  • GraphQLBundle: A GraphQL server for Symfony
  • WPGraphQL: A free, open-source WordPress plugin that provides an extendable GraphQL schema and API for any WordPress site

API Platform (github)#

API Platform is a fully-featured, flexible and extensible API framework built on top of Symfony. The following class is enough to create both a Relay-compatible GraphQL server and a hypermedia API supporting modern REST formats (JSON-LD, JSONAPI...):

<?php
 
namespace App\Entity;
 
use ApiPlatform\Core\Annotation\ApiResource;
use Doctrine\ORM\Mapping as ORM;
 
/**
 * Greet someone!
 *
 * @ApiResource
 * @ORM\Entity
 */
class Greeting
{
    /**
     * @ORM\Id
     * @ORM\Column(type="guid")
     */
    public $id;
 
    /**
     * @var string Your nice message
     *
     * @ORM\Column
     */
    public $hello;
}

Other API Platform features include data validation, authentication, authorization, deprecations, cache and GraphiQL integration.

GraphQLite (github)#

GraphQLite is a library that offers an annotations-based syntax for GraphQL schema definition. It is framework agnostic with bindings available for Symfony and Laravel.

This code declares a "product" query and a "Product" Type:

class ProductController
{
    /**
     * @Query()
     */
    public function product(string $id): Product
    {
        // Some code that looks for a product and returns it.
    }
}
 
/**
 * @Type()
 */
class Product
{
    /**
     * @Field()
     */
    public function getName(): string
    {
        return $this->name;
    }
    // ...
}

Other GraphQLite features include validation, security, error handling, loading via data-loader pattern...

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 Siler\Diactoros;
use Siler\Graphql;
use Siler\Http;
 
$typeDefs = file_get_contents(__DIR__.'/schema.graphql');
$resolvers = [
    'Query' => [
        'hello' => 'world',
    ],
];
$schema = Graphql\schema($typeDefs, $resolvers);
 
echo "Server running at http://127.0.0.1:8080";
 
Http\server(Graphql\psr7($schema), function (\Throwable $err) {
    var_dump($err);
    return Diactoros\json([
        'error'   => true,
        'message' => $err->getMessage(),
    ]);
})()->run();

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

Swift#

  • Graphiti: Swift library for building GraphQL schemas/types fast, safely and easily.

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
 
class Query(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'
 
class QueryType < GraphQL::Schema::Object
  graphql_name 'Query'
  field :hello do
    type types.String
    resolve -> (obj, args, ctx) { 'Hello world!' }
  end
end
 
class Schema < GraphQL::Schema
  query QueryType
end
 
puts Schema.execute('{ hello }').to_json

There are also nice bindings for Relay and Rails.

Agoo#

A high performance web server with support for GraphQL. Agoo strives for a simple, easy to use API for GraphQL.

require 'agoo'
 
class Query
  def hello
    'hello'
  end
end
 
class Schema
  attr_reader :query
 
  def initialize
    @query = Query.new()
  end
end
 
Agoo::Server.init(6464, 'root', thread_count: 1, graphql: '/graphql')
Agoo::Server.start()
Agoo::GraphQL.schema(Schema.new) {
  Agoo::GraphQL.load(%^type Query { hello: String }^)
}
sleep
 
# To run this GraphQL example type the following then go to a browser and enter
# a URL of localhost:6464/graphql?query={hello}
#
# ruby hello.rb

Rust#

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

OCaml / Reason#

ocaml-graphql-server: GraphQL server library for OCaml and Reason#

GraphQL Clients#

C# / .NET#

Clojurescript#

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

Elm#

Flutter#

  • graphql: A GraphQL client implementation in Flutter.

Go#

Java / Android#

  • Apollo Android: A strongly-typed, caching GraphQL client for the JVM, Android and Kotlin native.

  • 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.
  • urql (github): A highly customizable and versatile GraphQL client for React.
  • graphqurl (npm): curl for GraphQL with autocomplete, subscriptions and GraphiQL. Also a dead-simple universal javascript GraphQL client.

Julia#

  • Diana.jl: A Julia GraphQL server implementation.

Kotlin#

  • graphql-kotlin: A set of GraphQL libraries that includes a lightweight, typesafe GraphQL HTTP client.

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.
  • Graphaello: A Tool for Writing Declarative, Type-Safe and Data-Driven Applications in SwiftUI using GraphQL and Apollo

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.

R#

  • ghql: General purpose GraphQL R client.

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.
  • GraphQL Code Generator: GraphQL code generator with flexible support for custom plugins and templates like Typescript (frontend and backend), React Hooks, resolvers signatures and more.
  • GraphQL Inspector: Compare schemas, validate documents, find breaking changes, find similar types, schema coverage, and more.
  • GraphQL Config: One configuration for all your GraphQL tools (supported by most tools, editors & IDEs).
  • GraphQL CLI: A command line tool for common GraphQL development workflows.
  • GraphQL Scalars: A library of custom GraphQL scalar types for creating precise, type-safe GraphQL schemas.
  • GraphQL Tools: A set of utils for faster development of GraphQL tools (Schema and documents loading, Schema merging and more).
  • SOFA: Generate REST API from your GraphQL API.
  • GraphQL-ESLint: integrates GraphQL AST in the ESLint core (as a parser).
  • GraphQL Modules: lets you separate your backend implementation to small, reusable, easy-to-implement and easy-to-test pieces.
  • GraphQL Mesh: allows you to use GraphQL query language to access data in remote APIs that don't run GraphQL (and also ones that do run GraphQL). It can be used as a gateway to other services, or run as a local GraphQL schema that aggregates data from remote APIs.

Services#

  • Apollo Graph Manager: A cloud 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.
  • Prisma (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.
  • 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.
  • Elide: A Java library that can expose a JPA annotated data model as a GraphQL service over any relational database.
  • Hasura (github): Hasura connects to your databases & microservices and instantly gives you a production-ready GraphQL API.
  • FaunaDB: Create an instant GraphQL backend by importing a gql schema. The database will create relations and indexes for you, so you'll be ready to query in seconds, without writing any database code. Serverless pricing, free to get started.
  • Back4App: Back4App is a Backend as a Service Platform that helps you Build and Scale modern applications based on GraphQL.

More Stuff#

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