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 AppEntity;

use ApiPlatformCoreAnnotationApiResource;
use DoctrineORMMapping as ORM;

/**
 * Greet someone!
 *
 * @ApiResource
 * @ORMEntity
 */
class Greeting
{
    /**
     * @ORMId
     * @ORMColumn(type="guid")
     */
    public $id;

    /**
     * @var string Your nice message
     *
     * @ORMColumn
     */
    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 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);
    return Diactorosjson([
        '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

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 #

  • 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.
  • 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.

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 Toolkit: 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.

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.

More Stuff #

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