Code

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 rootValue = { hello: () => 'Hello world!' };

var source = '{ hello }';

graphql({ schema, source, rootValue }).then((response) => {
  console.log(response);
});

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

npm install apollo-server-express apollo-server-core express graphql

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

import { ApolloServer } from 'apollo-server-express';
import { ApolloServerPluginDrainHttpServer } from 'apollo-server-core';
import express from 'express';
import http from 'http';

async function startApolloServer(typeDefs, resolvers) {
  const app = express();

  const httpServer = http.createServer(app);

  const server = new ApolloServer({
    typeDefs,
    resolvers,
    plugins: [ApolloServerPluginDrainHttpServer({ httpServer })],
  });

  await server.start();

  server.applyMiddleware({ app });

  await new Promise(resolve => httpServer.listen({ port: 4000 }, resolve));

  console.log(`🚀 Server ready at http://localhost:4000${server.graphqlPath}`);
}

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

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'));

• Built around the Fetch API Request & Response 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:

npm install graphql-yoga graphql

Then create a server using the createServer import:

import { createServer } from 'http'
import { createSchema, createYoga } from 'graphql-yoga'

createServer(
  createYoga({
    schema: createSchema({
      typeDefs: /* GraphQL */ `
        type Query {
          hello: String
        }
      `,
      resolvers: {
        Query: {
          hello: () => 'Hello Hello Hello',
        },
      },
    })
  })
).listen(4000, () => {
  console.info('GraphQL Yoga is listening on http://localhost:4000/graphql')
})

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

To run an hello world script with mercurius:

npm install fastify mercurius

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

const Fastify = require('fastify')
const mercurius = require('mercurius')

const schema = `
  type Query {
    hello(name: String): String!
  }
`

const resolvers = {
  Query: {
    hello: async (_, { name }) => `hello ${name || 'world'}`
  }
}

const app = Fastify()
app.register(mercurius, {
  schema,
  resolvers
})

app.listen(3000)

// Call IT!
// curl 'http://localhost:3000/graphql' \
//  -H 'content-type: application/json' \
//  --data-raw '{"query":"{ hello(name:\"Marcurius\") }" }'

To run a hello world server with GraphQL Helix:

npm install graphql graphql-helix express

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

const express = require('express')
const {
  GraphQLObjectType,
  GraphQLSchema,
  GraphQLString
} = require('graphql');
const {
  getGraphQLParameters,
  processRequest,
  renderGraphiQL,
  shouldRenderGraphiQL
} = require('graphql-helix');

const schema = new GraphQLSchema({
  query: new GraphQLObjectType({
    name: 'Query',
    fields: {
      hello: {
        type: GraphQLString,
        resolve: () => 'Hello world!',
      },
    },
  }),
});

const app = express();

app.use(express.json());

app.use('/graphql', async (req, res) => {
  const request = {
    body: req.body,
    headers: req.headers,
    method: req.method,
    query: req.query,
  };

  if (shouldRenderGraphiQL(request)) {
    res.send(renderGraphiQL());
  } else {
    const { operationName, query, variables } = getGraphQLParameters(request);

    const result = await processRequest({
      operationName,
      query,
      variables,
      request,
      schema,
    });

    if (result.type === 'RESPONSE') {
      result.headers.forEach(({ name, value }) => res.setHeader(name, value));
      res.status(result.status);
      res.json(result.payload);
    } else {
    // graphql-helix also supports subscriptions and incremental delivery (i.e. @defer and @stream directives)
    // out of the box. See the repo for more complete examples that also implement those features.
    }
  }
});

app.listen(4000, () =>
  console.log('Now browse to http://localhost:4000/graphql');
)

This example uses Express, but GraphQL Helix is framework- and runtime-agnostic -- it can run in Node, Deno and the browser. GraphQL Helix provides you with a handful of utility functions to build your own HTTP server but leaves the ultimate implementation details up to you.

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

npm install @graphql-box/core @graphql-box/server @graphql-box/client @graphql-box/request-parser @graphql-box/cache-manager @graphql-box/debug-manager @graphql-box/execute @graphql-box/helpers @cachemap/core @cachemap/reaper @cachemap/redis @cachemap/constants @cachemap/types

import Cachemap from "@cachemap/core";
import redis from "@cachemap/redis";
import reaper from "@cachemap/reaper";
import CacheManager from "@graphql-box/cache-manager";
import Client from "@graphql-box/client";
import DebugManager from "@graphql-box/debug-manager";
import Execute from "@graphql-box/execute";
import RequestParser from "@graphql-box/request-parser";
import Server from "@graphql-box/server";
import { makeExecutableSchema } from "@graphql-tools/schema";
import { performance } from "perf_hooks";
import { schemaResolvers, schemaTypeDefs } from "./schema";
import logger from './logger';

const schema = makeExecutableSchema({ typeDefs: schemaTypeDefs, resolvers: schemaResolvers });

const server = new Server({
  client: new Client({
    cacheManager: new CacheManager({
      cache: new Cachemap({
        name: "server-cache",
        reaper: reaper({ interval: 300000 }),
        store: redis(/* configure */),
      }),
      cascadeCacheControl: true,
      typeCacheDirectives: {
        // Add any type specific cache control directives in the format:
        // TypeName: "public, max-age=3",
      },
    }),
    debugManager: new DebugManager({
      environment: "server",
      log: (...args) => {
        logger.log(...args);
      },
      name: "SERVER",
      performance,
    }),
    requestManager: new Execute({ schema }),
    requestParser: new RequestParser({ schema }),
  }),
});

// Meanwhile... somewhere else in your code

app.use("api/graphql", graphqlServer.request());

A powerful JavaScript GraphQL client, designed to work well with React, React Native, Angular 2, or just plain JavaScript.

A JavaScript library for application development using cloud services, which supports GraphQL backend and React components for working with GraphQL data.

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.

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.

urql 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 @urql/exchange-graphcache
• Fully customizable behaviour via "exchanges" (addon packages)

curl for GraphQL with autocomplete, subscriptions and GraphiQL. Also a dead-simple universal javascript GraphQL client.

• 🥇 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#

npm install graphql-hooks

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

import { GraphQLClient, ClientContext } from 'graphql-hooks'

const client = new GraphQLClient({
  url: '/graphql'
})

function App() {
  return (
    <ClientContext.Provider value={client}>
      {/* children */}
    </ClientContext.Provider>
  )
}

Now in your child components you can make use of useQuery:

import { useQuery } from 'graphql-hooks'

const HOMEPAGE_QUERY = `query HomePage($limit: Int) {
  users(limit: $limit) {
    id
    name
  }
}`

function MyComponent() {
  const { loading, error, data } = useQuery(HOMEPAGE_QUERY, {
    variables: {
      limit: 10
    }
  })

  if (loading) return 'Loading...'
  if (error) return 'Something Bad Happened'

  return (
    <ul>
      {data.users.map(({ id, name }) => (
        <li key={id}>{name}</li>
      ))}
    </ul>
  )
}

A simple JavaScript GraphQL client that works in all JavaScript environments (the browser, Node.js, and React Native).

Tiny GraphQL client library using template strings.

GraphQL client for TypeScript, automatically infers the type of the returned data according to the strongly typed query request

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

npm install @graphql-box/core @graphql-box/client @graphql-box/request-parser @graphql-box/cache-manager @graphql-box/debug-manager @graphql-box/fetch-manager @graphql-box/helpers @cachemap/core @cachemap/reaper @cachemap/indexed-db @cachemap/constants @cachemap/types

import Cachemap from "@cachemap/core";
import indexedDB from "@cachemap/indexed-db";
import reaper from "@cachemap/reaper";
import CacheManager from "@graphql-box/cache-manager";
import Client from "@graphql-box/client";
import DebugManager from "@graphql-box/debug-manager";
import FetchManager from "@graphql-box/fetch-manager";
import RequestParser from "@graphql-box/request-parser";
import introspection from "./introspection-query";

const requestManager = new FetchManager({
  apiUrl: "/api/graphql",
  batchRequests: true,
  logUrl: "/log/graphql",
});

const client = new Client({
  cacheManager: new CacheManager({
    cache: new Cachemap({
      name: "client-cache",
      reaper: reaper({ interval: 300000 }),
      store: indexedDB(/* configure */),
    }),
    cascadeCacheControl: true,
    typeCacheDirectives: {
      // Add any type specific cache control directives in the format:
      // TypeName: "public, max-age=3",
    },
  }),
  debugManager: new DebugManager({
    environment: "client",
    log: (message, data, logLevel) => {
      requestManager.log(message, data, logLevel);
    },
    name: "CLIENT",
    performance: self.performance,
  }),
  requestManager,
  requestParser: new RequestParser({ introspection }),
});

// Meanwhile... somewhere else in your code

const { data, errors } = await client.request(queryOrMutation);

An all purpose GraphQL client with view layer integrations for multiple frameworks in just 1.6kb.

A simple JavaScript GraphQL client，Let the *.gql file be used as a module through webpack loader.

An interactive in-browser GraphQL IDE.

GraphQL code generator with flexible support for custom plugins and templates like Typescript (frontend and backend), React Hooks, resolvers signatures and more.

One configuration for all your GraphQL tools (supported by most tools, editors & IDEs).

A set of utils for faster development of GraphQL tools (Schema and documents loading, Schema merging and more).

A library of custom GraphQL scalar types for creating precise, type-safe GraphQL schemas.

GraphQL-ESLint integrates GraphQL AST in the ESLint core (as a parser).

Compare schemas, validate documents, find breaking changes, find similar types, schema coverage, and more.

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#

const { ApolloServer } = require('apollo-server')
const { makeExecutableSchema } = require('@graphql-tools/schema')

const typeDefs = `
type Query {
  hello(name: String): String
  bye(name: String): String
}
`
const resolvers = {
  Query: {
    hello: (root, args, context, info) => {
      console.log(`3. resolver: hello`)
      return `Hello ${args.name ? args.name : 'world'}!`
    },
    bye: (root, args, context, info) => {
      console.log(`3. resolver: bye`)
      return `Bye ${args.name ? args.name : 'world'}!`
    },
  },
}

const logInput = async (resolve, root, args, context, info) => {
  console.log(`1. logInput: ${JSON.stringify(args)}`)
  const result = await resolve(root, args, context, info)
  console.log(`5. logInput`)
  return result
}

const logResult = async (resolve, root, args, context, info) => {
  console.log(`2. logResult`)
  const result = await resolve(root, args, context, info)
  console.log(`4. logResult: ${JSON.stringify(result)}`)
  return result
}

const schema = makeExecutableSchema({ typeDefs, resolvers })

const schemaWithMiddleware = applyMiddleware(schema, logInput, logResult)

const server = new ApolloServer({
  schema: schemaWithMiddleware,
})

await server.listen({ port: 8008 })

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.

import { rule, shield, and, or, not } from 'graphql-shield'

// Rules

const isAuthenticated = rule({ cache: 'contextual' })(
  async (parent, args, ctx, info) => {
    return ctx.user !== null
  },
)

const isAdmin = rule({ cache: 'contextual' })(
  async (parent, args, ctx, info) => {
    return ctx.user.role === 'admin'
  },
)

const isEditor = rule({ cache: 'contextual' })(
  async (parent, args, ctx, info) => {
    return ctx.user.role === 'editor'
  },
)

// Permissions

const permissions = shield({
  Query: {
    frontPage: not(isAuthenticated),
    fruits: and(isAuthenticated, or(isAdmin, isEditor)),
    customers: and(isAuthenticated, isAdmin),
  },
  Mutation: {
    addFruitToBasket: isAuthenticated,
  },
  Fruit: isAuthenticated,
  Customer: isAdmin,
})

// Server

const server = new GraphQLServer({
  typeDefs,
  resolvers,
  middlewares: [permissions],
  context: (req) => ({
    ...req,
    user: getUser(req),
  }),
})

builds a powerful, extensible and performant GraphQL API from a PostgreSQL schema in seconds; saving you weeks if not months of development time.

A command line tool for common GraphQL development workflows.

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

import { ApolloServer } from "apollo-server"
import SchemaBuilder from "@giraphql/core"

const builder = new SchemaBuilder({})

builder.queryType({
  fields: t => ({
    hello: t.string({
      args: {
        name: t.arg.string({}),
      },
      resolve: (parent, { name }) => `hello, ${name || "World"}`,
    }),
  }),
})

new ApolloServer({
  schema: builder.toSchema({}),
}).listen(3000)

Real-Time with GraphQL for any GraphQL schema or transport.

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.

Coherent, zero-dependency, lazy, simple, GraphQL over WebSocket Protocol compliant server and client.

GraphQL Modules lets you separate your backend implementation to small, reusable, easy-to-implement and easy-to-test pieces.

Zero-dependency, HTTP/1 safe, simple, GraphQL over Server-Sent Events Protocol server and client.

Generate REST API from your GraphQL API.

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.

npm install --dev spectaql
# OR
yarn add -D spectaql

# Then generate your docs
npm run spectaql my-config.yml
# OR
yarn spectaql my-config.yml

An interface for building GraphQL language services for IDEs (diagnostics, autocomplete etc).

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.

npm install microfiber
# OR
yarn add microfiber

Then in JS:

import { Microfiber } from 'microfiber'

const introspectionQueryResults = {...}

const microfiber = new Microfiber(introspectionQueryResults)

// ...do some things to your schema with `microfiber`

const cleanedIntrospectonQueryResults = microfiber.getResponse()

An implementation of GraphQL for Go / Golang.

Go generate based graphql server library.

An active implementation of GraphQL in Golang (was https://github.com/neelance/graphql-go).

A GraphQL implementation with easy schema building, live queries, and batching.

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.

A Go/Golang library to help construct a graphql-go server supporting react-relay.

Develop spec compliant GraphQL servers in Go.

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 eggql hello world server just build and run this Go program:

package main

import "github.com/andrewwphillips/eggql"

func main() {
    http.Handle("/graphql", eggql.New(struct{ Message string }{Message: "hello, world"}))
    http.ListenAndServe(":80", nil)
}

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

$ curl -XPOST -d '{"query": "{ message }"}' localhost:80/graphql

and you will get this response:

{
  "data": {
    "message": "hello, world"
  }
}

An elegant low-level HTTP client for GraphQL.

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 interface{}.
• Production-readiness: genqlient is used in production at Khan Academy, where it supports millions of learners and teachers around the world.

A GraphQL client implementation in Go.

A GraphQL Go client with Mutation, Query and Subscription support.

An instant GraphQL to SQL compiler. Use as a standalone service or a Go library. Formerly super-graph.

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.

A PHP port of GraphQL reference implementation

A free, open-source WordPress plugin that provides an extendable GraphQL schema and API for any WordPress site

A GraphQL server for Laravel

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.

A GraphQL server for Symfony

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

A PHP GraphQL Framework.

A library to help construct a graphql-php server supporting react-relay.

A GraphQL server for WordPress. Based on GraphQL by PoP

GraphQL by PoP follows the code-first approach to generate the schema (it can be customized for different clients/applications). Fields are dynamically "subscribed" to types, and may or may not be added to the schema depending on the context.

This is how a User type is satisfied:

class UserTypeResolver extends AbstractTypeResolver
{
  public function getTypeName(): string
  {
    return 'User';
  }

  public function getSchemaTypeDescription(): ?string
  {
    $translationAPI = TranslationAPIFacade::getInstance();
    return $translationAPI->__('Representation of a user', 'users');
  }

  public function getID(object $user)
  {
    return $user->ID;
  }

  public function getTypeDataLoaderClass(): string
  {
    return UserTypeDataLoader::class;
  }
}

Please notice how the TypeResolver does not indicate which are its fields. It also does not load the objects from the database, but instead delegates this task to a TypeDataLoader.

Adding fields to the type is done via a FieldResolver:

class UserFieldResolver extends AbstractDBDataFieldResolver
{
  public static function getClassesToAttachTo(): array
  {
    return [
      UserTypeResolver::class,
    ];
  }

  public static function getFieldNamesToResolve(): array
  {
    return [
      'username',
      'email',
      'url',
    ];
  }

  public function getSchemaFieldDescription(
    TypeResolverInterface $typeResolver,
    string $fieldName
  ): ?string {
    $translationAPI = TranslationAPIFacade::getInstance();
    $descriptions = [
      'username' => $translationAPI->__("User's username handle", "users"),
      'email' => $translationAPI->__("User's email", "users"),
      'url' => $translationAPI->__("URL of the user's profile in the website", "users"),
    ];
    return $descriptions[$fieldName];
  }

  public function getSchemaFieldType(
    TypeResolverInterface $typeResolver,
    string $fieldName
  ): ?string {
    $types = [
      'username' => SchemaDefinition::TYPE_STRING,
      'email' => SchemaDefinition::TYPE_EMAIL,
      'url' => SchemaDefinition::TYPE_URL,
    ];
    return $types[$fieldName];
  }

  public function resolveValue(
    TypeResolverInterface $typeResolver,
    object $user,
    string $fieldName,
    array $fieldArgs = []
  ) {
    switch ($fieldName) {
      case 'username':
        return $user->user_login;

      case 'email':
        return $user->user_email;

      case 'url':
        $userService = UserServiceFacade::getInstance();
        return $userService->getUserProfileURL($user->ID);
    }

    return null;
  }
}

The definition of a field for the GraphQL schema, and its resolution, is split into a multitude of functions from the FieldResolver:

• getSchemaFieldDescription
• getSchemaFieldType
• resolveValue
• getSchemaFieldArgs
• isSchemaFieldResponseNonNullable
• getImplementedInterfaceClasses
• resolveFieldTypeResolverClass
• resolveFieldMutationResolverClass

This code is more legible than if all functionality is satisfied through a single function, or through a configuration array, making it easier to implement and maintain the resolvers.

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 arrays, 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.

Use GraphQL to define your Domain Model for CQRS/ES and let serge generate code to handle GraphQL requests.

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.

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.

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:

// build.gradle.kts
implementation("com.expediagroup", "graphql-kotlin-spring-server", latestVersion)

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 application.yml file:

graphql:
  packages:
    - "com.your.package"

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 graphql-kotlin-spring-server auto-configuration library.

@Component
class HelloWorldQuery : Query {
  fun helloWorld() = "Hello World!!!"
}

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

type Query {
  helloWorld: String!
}

See graphql-kotlin docs for additial details.

The GraphQL Spring Boot turns any Spring Boot application into a GraphQL Server

Started includes features such as:

• Use a schema-driven API with the help of GraphQL Java Tools
• Optionally choose to use an annotation driven schema with the help of GraphQL-Java Annotations
• Embedded GraphiQL tool for schema introspection and query debugging
• Embedded GraphQL Playground tool for schema introspection and query debugging
• Embedded the GraphQL Voyager tool to represent your GraphQL API as an interactive graph

See GraphQL Java Kickstart Getting Started for how to get started.

Spring for GraphQL provides support for Spring applications built on GraphQL Java.

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

• Server 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:

@Controller
public class GreetingController {

    @QueryMapping
    public String hello() {
        return "Hello, world!";
    }

}

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

Here's an example on how to create a simple schema based on a kotlin data class plus a property resolver that gets applied onto your class.

data class Article(val id: Int, val text: String)

fun main() {
    val schema = KGraphQL.schema {
        query("article") {
            resolver { id: Int?, text: String ->
                Article(id ?: -1, text)
            }
        }
        type<Article> {
            property<String>("fullText") {
                resolver { article: Article ->
                    "${article.id}: ${article.text}"
                }
            }
        }
    }

    schema.execute("""
        {
            article(id: 5, text: "Hello World") {
                id
                fullText
            }
        }
    """).let(::println)
}

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. Example below shows how to set up a GraphQL server within Ktor and it will give you a GraphQL Playground out of the box by entering localhost:8080/graphql.

fun Application.module() {
  install(GraphQL) {
    playground = true 
    schema {
      query("hello") {
        resolver { -> "World!" }
      }
    }
  }
}

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

Introduce#

1. SpringBoot has introduced Spring GraphQL since 2.7. Jimmer provides specialized API for rapid development of Spring GraphQL-based applications.

2. Support two APIs: Java API & kotlin API.

3. Powerful and GraphQL friendly caching support.

4. Faster than other popular ORM solutions, please see the bechmark: https://babyfish-ct.github.io/jimmer/docs/benchmark/

5. More powerful than other popular ORM solutions.

   Three aspects should be considered in ORM design:

   a. Query. b. Update. c. Cache.

   Each aspect is aimed at object trees with arbitrary depth rather than simple objects. This distinctive design brings convenience unmatched by other popular solutions.

Links#

• Youtube video: https://www.youtube.com/watch?v=Rt5zNv0YR2E

• Documentation: https://babyfish-ct.github.io/jimmer/

• Project Home: https://github.com/babyfish-ct/jimmer

• GraphQL example for Java: https://github.com/babyfish-ct/jimmer/tree/main/example/java/jimmer-sql-graphql

• GraphQL example for Kotlin: https://github.com/babyfish-ct/jimmer/tree/main/example/kotlin/jimmer-sql-graphql-kt

MicroProfile GraphQL is a GraphQL server and client specification for building GraphQL applications. It's unique annotation-based API approach enables rapid application development. Applications coded to the MP GraphQL APIs are portable, and can be deployed into Java server runtimes such as Open Liberty, Quarkus, Helidon and Wildfly. This means that your applications can make use of other Jakarta and MicroProfile technologies.

MP GraphQL features include:

• Annotation-based APIs
• Integration with Jakarta CDI
• Type-safe and dynamic client APIs
• Exception handling
• Easy integration with Jakarta and MicroProfile technologies

Want to get started? Check out these resouces:

• Learn how to create and deploy a server side app in Open Liberty.
• Learn how to create a client application in Open Liberty.
• Learn how to create and deploy a server side app in Quarkus.
• Quick tutorial to build a simple sample weather application.

Or these videos:

• Integrating GraphQL and JPA
• Writing Queryable APIs with MP GraphQL

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.

query basicMapValue($userIds:[Int]){
    userInfoList(userIds:$userIds)
    {
        id
        age
        firstName
        lastName
        fullName: stringHolder @map(mapper: "firstName + lastName")
    }
}


query filterUserByAge($userId:[Int]){
    userInfoList(userIds: $userId)
    @filter(predicate: "age>=18")
    {
        userId
        age
        firstName
        lastName
    }
}

query parseFetchedValueToAnotherFieldArgumentMap($itemIds:[Int]){

        itemList(itemIds: $itemIds){
            # save sellerId as List<Long> with unique name "sellerIdList"
            sellerId @fetchSource(name: "sellerIdList")
            name
            saleAmount
            salePrice
        }

        userInfoList(userIds: 1)
        # transform the argument of "userInfoList" named "userIds" according to expression "sellerIdList" and expression argument, 
        # which mean replace userIds value by source named "sellerIdList"
        @argumentTransform(argumentName: "userIds", 
            operateType: MAP, 
            expression: "sellerIdList", 
            dependencySources: ["sellerIdList"]
        ){
            userId
            name
            age
        }
}

See graphql-calculator README for more information.

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

// build.gradle.kts
import com.expediagroup.graphql.plugin.gradle.graphql

plugins {
    id("com.expediagroup.graphql") version $latestGraphQLKotlinVersion
}

dependencies {
  implementation("com.expediagroup:graphql-kotlin-spring-client:$latestGraphQLKotlinVersion")
}

graphql {
    client {
        // target GraphQL endpoint
        endpoint = "http://localhost:8080/graphql"
        // package for generated client code
        packageName = "com.example.generated"
    }
}

By default, GraphQL Kotlin plugins will look for query files under src/main/resources. Given HelloWorldQuery.graphql sample query:

query HelloWorldQuery {
  helloWorld
}

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

package com.example.generated

import com.expediagroup.graphql.client.types.GraphQLClientRequest
import kotlin.String
import kotlin.reflect.KClass

const val HELLO_WORLD_QUERY: String = "query HelloWorldQuery {\n    helloWorld\n}"

class HelloWorldQuery: GraphQLClientRequest<HelloWorldQuery.Result> {
    override val query: String = HELLO_WORLD_QUERY

    override val operationName: String = "HelloWorldQuery"

    override fun responseType(): KClass<HelloWorldQuery.Result> = HelloWorldQuery.Result::class

    data class Result(
        val helloWorld: String
    }
}

We can then execute our queries using target client.

package com.example.client

import com.expediagroup.graphql.client.spring.GraphQLWebClient
import com.expediagroup.graphql.generated.HelloWorldQuery
import kotlinx.coroutines.runBlocking

fun main() {
    val client = GraphQLWebClient(url = "http://localhost:8080/graphql")
    runBlocking {
        val helloWorldQuery = HelloWorldQuery()
        val result = client.execute(helloWorldQuery)
        println("hello world query result: ${result.data?.helloWorld}")
    }
}

See graphql-kotlin client docs for additional details.

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

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