Tools and Libraries | GraphQL

Install Steps if running locally on linux not on Dgraph Cloud:

Set your GraphQL Schema:

Fire up your favorite GraphQL Client pointed at and run mutations and queries

To run a hello world script from the command line:

Then run with this code in :

Relay is a JavaScript framework for building data-driven React applications.

• Declarative: Never again communicate with your data store using an imperative API. Simply declare your data requirements using GraphQL and let Relay figure out how and when to fetch your data.
• Colocation: Queries live next to the views that rely on them, so you can easily reason about your app. Relay aggregates queries into efficient network requests to fetch only what you need.
• Mutations: Relay lets you mutate data on the client and server using GraphQL mutations, and offers automatic data consistency, optimistic updates, and error handling.

See how to use Relay in your own project.

The following class is enough to create both a Relay-compatible GraphQL server and a hypermedia API supporting modern REST formats (JSON-LD, JSONAPI…):

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

is a GraphQL client that exposes a set of helpers for several frameworks. It’s built to be highly customisable and versatile so you can take it from getting started with your first GraphQL project all the way to building complex apps and experimenting with GraphQL clients.

• Currently supports React, React Native, Preact, Svelte, and Vue, and is supported by GraphQL Code Generator.
• Logical yet simple default behaviour and document caching, and normalized caching via
• Fully customizable behaviour via “exchanges” (addon packages)

• Built around the Fetch API & objects
• GraphQL over HTTP compliant
• Extensible GraphQL Engine powered by Envelop
• GraphQL Subscriptions over HTTP
• Handle file uploads with GraphQL
• Integrates with AWS Lambda, Cloudflare Workers, Deno, Express, Next.js, SvelteKit, and more.

To run a hello world server with graphql-yoga:

Then create a server using the import:

Depending on your deployment target, you may need to use an additional library. See the documentation for further details.

To run a Graphene hello world script:

Then run with this code in :

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

Strawberry Shake removes the complexity of state management and lets you interact with local and remote data through GraphQL.

You can use Strawberry Shake to:

• Generate a C# client from your GraphQL queries.
• Interact with local and remote data through GraphQL.
• Use reactive APIs to interact with your state.

Hot Chocolate takes the complexity away from building a fully-fledged GraphQL server and lets you focus on delivering the next big thing.

To run a hello world script with :

Then run with this code in :

There are also nice bindings for Relay and Rails.

Here’s an example of a Strawberry hello world, first install the library:

Create an file with this content:

Then run and you will have a basic schema server running on .

Strawberry also has views for ASGI, Flask and Django and provides utilities like dataloaders and tracing.

Apollo Kotlin (formerly known as Apollo Android) is a GraphQL client with support for Android, Java8+, iOS and Kotlin multiplatform in general. It features:

• Java and Kotlin Multiplatform code generation
• Queries, Mutations and Subscriptions
• Reflection-free parsing
• Normalized cache
• Custom scalar types
• HTTP cache
• Auto Persisted Queries
• Query batching
• File uploads
• Espresso IdlingResource
• Fake models for tests
• AppSync and graphql-ws websockets
• GraphQL AST parser

GraphQL Shield helps you create a permission layer for your application. Using an intuitive rule-API, you’ll gain the power of the shield engine on every request and reduce the load time of every request with smart caching. This way you can make sure your application will remain quick, and no internal data will be exposed.

Run Schemathesis via Docker against your GraphQL endpoint:

Schemathesis will generate queries matching your GraphQL schema and catch server crashes automatically. Generated queries have arbitrary depth and may contain any subset of GraphQL types defined in the input schema. They expose edge cases in your code that are unlikely to be found otherwise.

Note that you can write your app in any programming language; the tool will communicate with it over HTTP.

For example, running the command above against uncovers that running the query leads to a server error:

The DGS Framework (Domain Graph Service) is a GraphQL server framework for Spring Boot, developed by Netflix.

Features include:

• Annotation based Spring Boot programming model
• Test framework for writing query tests as unit tests
• Gradle Code Generation plugin to create types from schema
• Easy integration with GraphQL Federation
• Integration with Spring Security
• GraphQL subscriptions (WebSockets and SSE)
• File uploads
• Error handling
• Many extension points

See DGS Framework Getting Started for how to get started.

GiraphQL makes writing type-safe schemas simple, and works without a code generator, build process, or extensive manual type definitions.

To run an hello world script with :

Then run with this code in :

Ariadne can be installed with pip:

Minimal “Hello world” server example:

Run the server with uvicorn:

Microcks is a platform for turning your API and microservices assets - GraphQL schemas, OpenAPI specs, AsyncAPI specs, gRPC protobuf, Postman collections, SoapUI projects_ - into live simulations in seconds.

It also reuses these assets for running compliance and non-regression tests against your API implementation. We provide integrations with Jenkins, GitHub Actions, Tekton and many others through a simple CLI.

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

• 🥇 First-class hooks API
• ⚖️ Tiny bundle: only 7.6kB (2.8 gzipped)
• 📄 Full SSR support: see graphql-hooks-ssr
• 🔌 Plugin Caching: see graphql-hooks-memcache
• 🔥 No more render props hell
• ⏳ Handle loading and error states with ease

Quickstart

First you’ll need to create a client and wrap your app with the provider:

Now in your child components you can make use of :

GraphQL Kotlin provides a set of lightweight type-safe GraphQL HTTP clients. The library provides Ktor HTTP client and Spring WebClient based reference implementations as well as allows for custom implementations using other engines. Jackson and kotlinx-serialization type-safe data models are generated at build time by the provided Gradle and Maven plugins.

To generate Jackson models that will be used with GraphQL Kotlin Spring WebClient, add following to your Gradle build file:

By default, GraphQL Kotlin plugins will look for query files under . Given sample query:

Plugin will generate classes that are simple POJOs implementing GraphQLClientRequest interface and represent a GraphQL request.

We can then execute our queries using target client.

See graphql-kotlin client docs for additional details.

GraphQL Kotlin follows a code first approach for generating your GraphQL schemas. Given the similarities between Kotlin and GraphQL, such as the ability to define nullable/non-nullable types, a schema can be generated from Kotlin code without any separate schema specification. To create a reactive GraphQL web server add following dependency to your Gradle build file:

We also need to provide a list of supported packages that can be scanned for exposing your schema objects through reflections. Add following configuration to your file:

With the above configuration we can now create our schema. In order to expose your queries, mutations and/or subscriptions in the GraphQL schema you simply need to implement corresponding marker interface and they will be automatically picked up by auto-configuration library.

This will result in a reactive GraphQL web application with following schema:

See graphql-kotlin docs for additial details.

Spring for GraphQL provides support for Spring applications built on GraphQL Java. See the official Spring guide for how to build a GraphQL service in 15 minutes.

• It is a joint collaboration between the GraphQL Java team and Spring engineering.
• Our shared philosophy is to provide as little opinion as we can while focusing on comprehensive support for a wide range of use cases.
• It aims to be the foundation for all Spring, GraphQL applications.

Features:

• backend handling of GraphQL requests over HTTP, WebSocket, and RSocket.
• An annotation-based programming model where @Controller components use annotations to declare handler methods with flexible method signatures to fetch the data for specific GraphQL fields. For example:

• frontend support for executing GraphQL requests over HTTP, WebSocket, and RSocket.
• Dedicated support for testing GraphQL requests over HTTP, WebSocket, and RSocket, as well as for testing directly against a server.

To get started, check the Spring GraphQL starter on https://start.spring.io and the samples in this repository.

genqlient is a Go library to easily generate type-safe code to query a GraphQL API. It takes advantage of the fact that both GraphQL and Go are typed languages to ensure at compile-time that your code is making a valid GraphQL query and using the result correctly, all with a minimum of boilerplate.

genqlient provides:

• Compile-time validation of GraphQL queries: never ship an invalid GraphQL query again!
• Type-safe response objects: genqlient generates the right type for each query, so you know the response will unmarshal correctly and never need to use .
• Production-readiness: genqlient is used in production at Khan Academy, where it supports millions of learners and teachers around the world.

WunderGraph composes all your APIs into a single unified GraphQL API and allows you to expose your Graph as a secure and type-safe JSON-RPC API.

To get started with WunderGraph, you can use to bootstrap a new project:

On the client side, WunderGraph’s JSON-RPC API integrates very well with frameworks like Next.js, SWR and React Query, while one the backend, we’re able to leverage the power of “Server-Side-Only GraphQL”. Handle authentication, authorization, validation, joins and more right in the Query Layer.

The Query above requires the user to be authenticated, injects the user’s name and email from the JWT token and validates the message against a JSON Schema.

Here’s another example showcasing how we can use Server-Side GraphQL with WunderGraph’s unique join capabilities, composing data from two different APIs into a single GraphQL response.

The full example can be found on GitHub.

SpectaQL is a Node.js library that generates static documentation for a GraphQL schema using a variety of options:

• From a live endpoint using the introspection query.
• From a file containing an introspection query result.
• From a file, files or glob leading to the schema definitions in SDL.

Out of the box, SpectaQL generates a single 3-column HTML page and lets you choose between a couple built-in themes. A main goal of the project is to be easily and extremely customizable—it is themeable and just about everything can be overridden or customized.

GraphQL Middleware is a schema wrapper which allows you to manage additional functionality across multiple resolvers efficiently.

Features

💡 Easy to use: An intuitive, yet familiar API that you will pick up in a second. 💪 Powerful: Allows complete control over your resolvers (Before, After). 🌈 Compatible: Works with any GraphQL Schema.

Example

To run a Siler hello world script:

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

GQty is a query builder, a query fetcher and a cache manager solution all-in-one.

You interact with your GraphQL endpoint via Proxy objects. Under the hood, GQty captures what is being read, checks cache validity, fetch missing contents and then updates the cache for you.

Start using GQty by simply running our interactive codegen:

GQty also provides framework specific integrations such as and , which can be installed via our CLI.

An example of defining a GraphQL query and running it with :

An example of a simple GraphQL schema and query with :

Apollo Router Core

The Apollo Router Core is a configurable, high-performance graph router written in Rust to run a federated supergraph that uses Apollo Federation 2.

Apollo Router Core is free, source-available, well-tested, regularly benchmarked, includes most major features of Apollo Gateway and is able to serve production-scale workloads.

GraphOS Router

In conjunction with the Apollo GraphOS platform, GraphOS Router is the enterprise-grade runtime plane and a client’s entry point to your federated supergraph. Configure it to secure your supergraph, monitor and optimize performance, extend functionality, and more.

To run a tartiflette hello world script:

Then run with this code in :

There is also a nice HTTP wrapper.

graphql-go-tools implements all basic blocks for building GraphQL Servers, Gateways and Proxy Servers. From lexing, parsing, validation, normalization, all the way up to query planning and execution.

It can also be understood as a GraphQL Compiler, with the ability to add your own backends. Just by implementing a few interfaces, you’re able to teach the compiler how to talk GraphQL to any backend.

The following backends are already implemented: GraphQL, with support for Apollo Federation / Supergraph. Databases: PostgreSQL, MySQL, SQLite, CockroachDB, MongoDB, SQLServer, OpenAPI / REST and Kafka.

To get a sense on how to implement a new backend, check out the Static Data Source, as it’s the simplest one.

It’s used in production by many enterprises for multiple years now, battle tested and actively maintained.

SwiftGraphQL is a Swift code generator and a lightweight GraphQL client. It lets you create queries using Swift, and guarantees that every query you create is valid.

The library is centered around three core principles:

🚀 If your project compiles, your queries work. 🦉 Use Swift in favour of GraphQL wherever possible. 🌳 Your application model should be independent of your schema.

Here’s a short preview of the SwiftGraphQL code

It is framework agnostic with bindings available for Symfony and Laravel. This code declares a “product” query and a “Product” Type:

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

Run against your GraphQL endpoint. Build your query in an intuitive TUI and execute it. The response from the server is written to standard output.

A client library for rust that generates queries from types you provide, verifying that the types match the shape of your schema.

It provides a generator to bootstrap types from existing GraphQL queries.

Usage example:

Install Ariadne Codegen:

Create file:

Add section to your :

Generate client:

And use it in your Python projects:

1. Create

2. Develop

Example service:

3. Query

The utility is based on and shares the same external dependencies. The command line arguments are almost the same, except it takes an extra file for the request document and there is no equivalent to :

This utility should output one header and one source file for each request document. A request document may contain more than one operation, in which case it will output definitions for all of them together. You may limit the output to a single operation from the request document by specifying the (or ) argument with the operation name.

The generated code depends on the library for serialization of built-in types. If you link the generated code, you’ll also need to link , for the pre-parsed, pre-validated request AST, and for the implementation.

Example implementation of a GraphQL server with type-level representation of the schema auto-generated:

See our docs for more information about how to build your own GraphQL server and the library example for a more end-to-end example that includes a client written in Elm!

The ZeroQL is a high-performance C#-friendly GraphQL client. It supports Linq-like syntax, and doesn’t require Reflection.Emit or expressions. As a result, at runtime provides performance very close to a raw HTTP call.

You can use ZeroQL to:

• Generate a C# client from GraphQL schema.
• Generate and execute graphql queries from your C# code.
• Don’t require writing GraphQL manually.
• Supports .Net Core, .Net Framework, Xamarin, Unity apps.

Code that executes a hello world GraphQL query with :

Less is more! Please check it out the docs.

To run a client:

• Download and install Ballerina Language
• Then run to run the service, with this code in the file:

Features

• Dependently-typed response retrieval with Ballerina type inferring
• Custom client generation support

To run a hello world server:

• Download and install Ballerina Language
• Then run to run the service, with this code in the file:

Features

• Built with Ballerina and model, which are first-class citizens in Ballerina
• Supports subscriptions over websocket (No additional libraries needed)
• Supports file upload
• Built-in GraphiQL client

Hive Gateway is a fully open-source, MIT-licensed GraphQL router that can act as a GraphQL Federation gateway, a subgraph or a proxy gateway for any GraphQL API service.

Hive Gateway provides a flexible, open-source solution tailored to meet the needs of modern GraphQL architectures.

It supports deployment as a standalone binary, a Docker image, or a JavaScript package, making it compatible with environments such as Node.js, Bun, Deno, Google Cloud Functions, Azure Functions, AWS Lambda, or Cloudflare Workers.

GraphQL Calculator is a lightweight graphql calculation engine, which is used to alter execution behavior of graphql query.

Here are some examples on how to use GraphQL Calculator on graphql query.

See graphql-calculator README for more information.

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.

• MetaCPAN documentation

  • Mojolicious-Plugin-GraphQL - connect your GraphQL service to a Mojolicious app

  • GraphQL-Plugin-Convert-DBIC - automatically connect your DBIx::Class schema to GraphQL

  • GraphQL-Plugin-Convert-OpenAPI - automatically connect any OpenAPI service (either local Mojolicious one, or remote) to GraphQL

graphql_query is complete GraphQL query string builder for python. With graphql_query you can The documentation for graphql_query can be found at https://denisart.github.io/graphql-query.

Code for the simple query

it is

For generation of the following query

we have

PSGraphQL is a PowerShell module for working with GraphQL endpoints from scripts, shells, and automation workflows. It provides commands for sending GraphQL queries and mutations, passing variables, setting headers, and returning either PowerShell objects or raw JSON.

Install it from the PowerShell Gallery:

Run a simple GraphQL query:

PSGraphQL can also send mutations, include operation names and variables, use custom headers for authentication, and read GraphQL queries from files.

• GraphQL Java client: it generates the Java classes that call the GraphQL endpoint, and the POJO that will contain the data returned by the server. The GraphQL endpoint can then be queried by using a simple call to a Java method (see sample below)
• GraphQL Java server: it is based on graphql-java (listed here above). It generates all the boilerplate code. You’ll only have to implement what’s specific to your server, which are the joins between the GraphQL types. GraphQL Java Generator is available as a Maven Plugin. A Gradle plugin is coming soon. Please note that GraphQL Java Generator is an accelerator: the generated code doesn’t depend on any library specific to GraphQL Java Generator. So, it helps you to start building application based on graphql-java. Once the code is generated, you can decide to manually edit it as any standard java application, and get rid of GraphQL Java Generator. Of course you can, and should, according to us :), continue using GraphQL Java Generator when your project evolves.

• Querying, mutating and subscribing without manual writing of query strings (unless you want to!)
• Deserializing responses directly into Julia types
• Construction of Julia types from GraphQL objects
• Using introspection to help with querying

Quickstart

Install with Julia’s package manager

Connect to a server

Build a Julia type from a GraphQL object

And query the server, deserializing the response into this new type

Alternatively write the query string manually

GraPHPinator is feature complete PHP implementation of GraphQL server. Its job is transformation of query string into resolved Json result for a given Schema.

• Aims to be compliant with the latest draft of GraphQL specification.
• Fully typesafe, and therefore minimum required PHP version is 8.0. Sacrafices a tiny bit of convenience for huge amount of clarity and safety - no random configuration s, no mixed types, no variable function arguments - this library doesnt try to save you from verbosity, but makes sure you always know what you’ve got.
• Code first.
• Flexible. Easy to extend with extra functionality using Modules or middleware Directives.
• Includes some opt-in extensions which are out of scope of official specs:
  • Printer - Schema printing for GraPHPinator typesystem.
  • Extra types - Some useful and commonly used types, both scalar or composite.
  • Constraint directives - Typesystem directives to declare additional validation on top of GraphQL typesystem.
  • Where directives - Executable directives to filter values in lists.
  • File upload using multipart-formdata specs (currently bundled).
  • Query cost limit module - Modules to limit query cost by restricting maximum depth or number of nodes.
• Project is composed from multiple smaller packages, which may be used standalone:
  • Tokenizer - Lexical analyzer of GraphQL document.
  • Parser - Syntactic analyzer of GraphQL document.

Here’s an example of a qlient hello world.

first install the library:

Create a file with this content:

Close the file and run it using python:

The purpose of Eggql is to make it as simple as possible to create a GraphQL server. You don’t need to create GraphQL schema (though you can view the schema that is created if interested). It is currently in beta release but is a complete implementation of a GraphQL server apart from subscriptions.

Just to be clear it supports all of these GraphQL features: arguments (including defaults), objects/lists/enums/input/interface/union types, aliases, fragments, variables, directives, mutations, inline fragments, descriptions, introspection and custom scalars.

Tests (jMeter) show that it is as fast or faster than other Go implementations for simple queries. We’re working on enhancements for performance including caching, data-loader, complexity-limits, etc.

To run an hello world server just build and run this Go program:

This creates a root Query object with a single field. To test it send a query with curl:

and you will get this response:

Microfiber is a JavaScript library that allows:

• Digging through your Introspection Query Results for a specific Query, Mutation, Type, Field, Argument or Subscription.
• Removing a specific Query, Mutation, Type, Field/InputField, Argument or Subscription from your Introspection Query Results.
• Removing Queries, Mutations, Fields/InputFields or Arguments that refer to Type that does not exist in - or has been removed from - your Introspection Query Results.

Then in JS:

GraphQL Protect helps you protect your GraphQL API against abuse by providing a large number of plug-and-play protection mechanism with sane defaults, while still allowing you complete customizability.

Getting started with GraphQL Protect is as simple as pulling the provided container, or running the binary directly, and supplying it with your configuration.

GraphQL Protect offers the following protection mechanism, and more:

1. Trusted Documents (Persisted Operations)
2. Max Aliases
3. Max Tokens
4. Max Depth
5. Max Batch
6. Block Field Suggestions
7. Obfuscate upstream errors
8. Enforce POST
9. Access Logging
10. … and more!

Protecting your GraphQL API against abuse has never been easier, start protecting your API today.

The full example can be found on GitHub.

Here’s an example of how to create a simple schema based on a Kotlin data class plus a property resolver that gets applied onto your class:

KGraphQL is using coroutines behind the scenes to provide great asynchronous performance.

See KGraphQL docs for more in depth usage.

Ktor Plugin

KGraphQL has a Ktor plugin which gives you a fully functional GraphQL server with a single install function call. The example below shows how to set up a GraphQL server within Ktor and it will give you a GraphQL IDE out of the box by entering .

You can follow the Ktor tutorial to set up a KGraphQL server with Ktor.

The example below installs and initializes the GraphQLBox client with a persisted cache and debugging enabled.

The example below installs and initializes the GraphQLBox server with a persisted cache and debugging enabled.

You can install the package with pip

To use it, simply create a new class that inherits “” Suppose we have the following models.

Then we can create a complete CRUD+DALS for the models with the following code

Now you can use the that was generated for you,

or use in your existing schema root and

That’s it! You can test in graphiql or any other client that you use to test your GraphQL APIs..

Find more information in the official documentation.

Easily build your GraphQL schema for using PHP attributes instead of large configuration arrays.

A simple example:

This will result in the following GraphQL schema:

Available attributes: , , , , , , , , , , ,

A Quickstart for Django Graphbox:

1. Install the package:

2. Create a new Django project:

3. Create a new Django app:

4. Define your Django models in :

5. Create and run migrations:

6. Configure and Build your GraphQL Schema in :

7. Create a main Schema in (In this main schema you can add your own queries and mutations):

8. Add the GraphQL view to your :

9. Run the server:

10. Open the GraphiQL interface at and start querying your API!

You can find advanced examples with authentication, filters, validations and more on GitHub or pypi.

Linq2GraphQL generates C# classes from the GraphQL schema and and togheter with the nuget package Linq2GraphQL.Client it makes it possible to query the server using Linq expressions.

A simple query that will get the first 10 orders with the primitive properties of orders and the connected customer

An example mutation where we add a new customer and return the Customer Id.

GraphQL client library, wrapped around pydantic classes for type validation, provides a safe and simple way to query data from a GraphQL API.

Features:

• python objects to valid GraphQL string
• scalar query responses
• type-safety

Install

Brangr - Browse Any Graph

• Brangr is a simple, unique tool that any web server can host to provide a user-friendly browser/viewer for any GraphQL service (or many).

• Brangr formats GraphQL results attractively, via a selection of user-configurable layouts. It lets users extract the generated HTML, and its source JSON. It provides a clever schema browser. It has built-in docs.

• Brangr enables sites hosting it to present users with a collection of pre-fab GraphQL requests, which they can edit if desired, and let them create their own requests. And it allows sites to define custom CSS styling for all aspects of the formatted results.

• Try it at the public Brangr site.

Example

Brangr renders the above query as follows (though not in a quote block):

heroes...