GraphQL Cheat Sheet

Ask for exactly the fields you need

{
  film(id: "ZmlsbXM6MQ==") {
    title
    director
    releaseDate
  }
}

The same request with curl

curl -s https://swapi-graphql.netlify.app/graphql -H "Content-Type: application/json" -d '{"query": "{ film(id: \"ZmlsbXM6MQ==\") { title } }"}'

Schema, operations, resolvers

Types and the root Query

type Query {
  film(id: ID!): Film
}

type Film {
  id: ID!
  title: String!
  director: String
  characters: [Person!]!
}

Nested selections follow relationships

query {
  film(filmID: 1) {
    title
    planetConnection(first: 2) {
      planets { name }
    }
    characterConnection(first: 3) {
      characters { name }
    }
  }
}

Ask for the same field twice

query {
  first: film(filmID: 1) { title }
  latest: film(filmID: 6) { title }
}

Name every operation

query EmpireCast {
  film(filmID: 2) {
    __typename
    title
    characterConnection(first: 2) {
      characters { __typename name }
    }
  }
}

One request, independent reads

{
  product(by: { sku: "LAMP-01" }) { name price }
  orders(first: 1, status: PAID) { totalCount }
}

Never build queries by string concatenation

query Film($id: ID!, $cast: Int = 2) {
  film(id: $id) {
    title
    characterConnection(first: $cast) {
      characters { name }
    }
  }
}

# variables: {"id": "ZmlsbXM6Mw=="}

The HTTP body with variables

{
  "query": "query Film($id: ID!) { film(id: $id) { title } }",
  "variables": { "id": "ZmlsbXM6Mw==" },
  "operationName": "Film"
}

A missing required variable

query Order($id: ID!) {
  node(id: $id) { id }
}

A typo in a field name

{
  product(by: { sku: "LAMP-01" }) { nmae }
}

A list variable

query Products($skus: [String!]!) {
  products(skus: $skus) { sku price }
}

# variables: {"skus": ["LAMP-01", "BULB-07"]}

Enum values are strings in JSON

query Shipped($status: OrderStatus) {
  orders(first: 5, status: $status) {
    totalCount
    edges { node { id } }
  }
}

# variables: {"status": "SHIPPED"}

Reuse a selection

query TwoFilms {
  a: film(filmID: 4) { ...FilmCard }
  b: film(filmID: 5) { ...FilmCard }
}

fragment FilmCard on Film {
  title
  releaseDate
}

Pick fields by concrete type

query {
  search(text: "ai") {
    __typename
    ... on Product { sku price }
    ... on Customer { name }
  }
}

Fetch any object by global ID

query {
  node(id: "ord_8812") {
    id
    ... on Order { status total customer { name } }
  }
}

Spread an interface fragment into a union

query {
  search(text: "ai") { ...Ref }
}

fragment Ref on Node {
  __typename
  id
}

@include and @skip

query Film($withCrawl: Boolean!) {
  film(filmID: 1) {
    title
    openingCrawl @include(if: $withCrawl)
  }
}

# variables: {"withCrawl": false}

Built into the specification

type Product {
  stock: Int @deprecated(reason: "Use stockLevel.")
  stockLevel: Int
}

scalar DateTime @specifiedBy(url: "https://www.rfc-editor.org/rfc/rfc3339")

input ProductBy @oneOf {
  id: ID
  sku: String
}

@oneOf: exactly one field

{
  product(by: { id: "prd_1", sku: "LAMP-01" }) { name }
}

@defer sends slow parts later

import { buildSchema, parse, experimentalExecuteIncrementally } from 'graphql';

const schema = buildSchema(`
  directive @defer(if: Boolean! = true, label: String) on FRAGMENT_SPREAD | INLINE_FRAGMENT
  type Query { product: Product }
  type Product { name: String reviews: [String] }
`);

const rootValue = {
  product: {
    name: 'Desk lamp',
    reviews: async () => { await new Promise((r) => setTimeout(r, 50)); return ['Bright', 'Sturdy']; },
  },
};

const document = parse(`{ product { name ... @defer(label: "slow") { reviews } } }`);
const result = await experimentalExecuteIncrementally({ schema, document, rootValue });

console.log(JSON.stringify(result.initialResult));
for await (const next of result.subsequentResults) console.log(JSON.stringify(next));

A schema directive that changes a resolver

import { createSchema } from 'graphql-yoga';
import { mapSchema, getDirective, MapperKind } from '@graphql-tools/utils';
import { defaultFieldResolver, graphql } from 'graphql';

const typeDefs = `
  directive @upper on FIELD_DEFINITION
  type Query { greeting: String @upper, plain: String }
`;

const base = createSchema({ typeDefs, resolvers: { Query: { greeting: () => 'hello', plain: () => 'hello' } } });
const schema = mapSchema(base, {
  [MapperKind.OBJECT_FIELD]: (field) => {
    if (!getDirective(base, field, 'upper')?.[0]) return field;
    const resolve = field.resolve ?? defaultFieldResolver;
    return { ...field, resolve: async (...args) => String(await resolve(...args)).toUpperCase() };
  },
});

console.log(JSON.stringify(await graphql({ schema, source: '{ greeting plain }' })));

Input object in, payload out

mutation CreateOrder($input: CreateOrderInput!) {
  createOrder(input: $input) {
    order { id status total }
    userErrors { field message code }
  }
}

# variables: {"input": {"customerId": "cus_42", "items": [{"sku": "LAMP-01"}, {"sku": "BULB-07", "qty": 3}]}}

Business errors as data

mutation {
  createOrder(input: {
    customerId: "cus_42"
    items: [{ sku: "CHAIR-3", qty: 1 }, { sku: "DESK-9" }]
  }) {
    order { id }
    userErrors { field message code }
  }
}

The schema behind it

type Mutation {
  createOrder(input: CreateOrderInput!): CreateOrderPayload!
}

input CreateOrderInput {
  customerId: ID!
  items: [OrderItemInput!]!
  note: String
}

input OrderItemInput {
  sku: String!
  qty: Int! = 1
}

type CreateOrderPayload {
  order: Order
  userErrors: [UserError!]!
}

type UserError {
  field: [String!]
  message: String!
  code: String!
}

Top-level mutation fields run in sequence

mutation {
  first: addToCart(sku: "LAMP-01") { itemCount }
  second: addToCart(sku: "BULB-07") { itemCount }
}

Update the UI before the server answers

const [setStatus] = useMutation(SET_STATUS);

setStatus({
  variables: { id: 'ord_8813', status: 'PAID' },
  optimisticResponse: {
    setOrderStatus: { __typename: 'Order', id: 'ord_8813', status: 'PAID' },
  },
});

Results pushed when events happen

subscription OnOrderStatus {
  orderStatusChanged(id: "ord_8813") { id status }
}

# accept: text/event-stream

The resolver is an async generator

const resolvers = {
  Subscription: {
    orderStatusChanged: {
      subscribe: async function* (_, { id }) {
        for await (const order of orderEvents(id)) {
          yield { orderStatusChanged: order };
        }
      },
    },
  },
};

When to use subscriptions

The shop schema behind the order examples

"""Any object that can be refetched by its global ID."""
interface Node { id: ID! }

enum OrderStatus { PENDING PAID SHIPPED }

type Product implements Node {
  id: ID!
  sku: String!
  name: String!
  price: Float!
  stock: Int @deprecated(reason: "Use stockLevel.")
  stockLevel: Int
}


type Order implements Node {
  id: ID!
  status: OrderStatus!
  total: Float!
  createdAt: DateTime!
  customer: Customer!
  items: [OrderItem!]!
  note: String
}

union SearchResult = Product | Customer | Order

type Query {
  node(id: ID!): Node
  product(by: ProductBy!): Product
  products(skus: [String!]!): [Product]!
  search(text: String!): [SearchResult!]!
  orders(first: Int = 10, after: String, status: OrderStatus): OrderConnection!
  me: Customer
  price(sku: String!): Float!
}

Two ways to build the same schema

Split a schema with extend

type Query {
  me: Customer
}

extend type Query {
  orders(first: Int = 10, after: String): OrderConnection!
}

extend type Customer {
  loyaltyPoints: Int!
}

Kinds of types

A DateTime scalar in graphql-js 17

import { GraphQLScalarType, GraphQLSchema, GraphQLObjectType, GraphQLNonNull, Kind, graphql } from 'graphql';

const DateTime = new GraphQLScalarType({
  name: 'DateTime',
  coerceOutputValue: (d) => new Date(d).toISOString(),
  coerceInputValue: (v) => { const d = new Date(v); if (isNaN(d)) throw new TypeError('Invalid DateTime'); return d; },
  coerceInputLiteral: (ast) => (ast.kind === Kind.STRING ? new Date(ast.value) : undefined),
});

const schema = new GraphQLSchema({
  query: new GraphQLObjectType({
    name: 'Query',
    fields: {
      shipBy: {
        type: DateTime,
        args: { ordered: { type: new GraphQLNonNull(DateTime) } },
        resolve: (_, { ordered }) => new Date(ordered.getTime() + 2 * 864e5),
      },
    },
  }),
});

const source = 'query ($at: DateTime!) { shipBy(ordered: $at) }';
console.log(JSON.stringify(await graphql({ schema, source, variableValues: { at: '2026-10-14T09:00:00Z' } })));
console.log((await graphql({ schema, source, variableValues: { at: 'yesterday' } })).errors[0].message);

An error in a non-null field nulls its parent

{
  product(by: { sku: "LAMP-01" }) { name }
  price(sku: "DESK-9")
}

A nullable field keeps the damage local

{
  product(by: { sku: "CHAIR-3" }) {
    name
    stockLevel
  }
}

Rules of thumb

A field error with an extensions code

{
  me { name email }
}

Throw a GraphQLError to choose the message

import { GraphQLError } from 'graphql';

const resolvers = {
  Query: {
    me: (_, __, ctx) => {
      if (!ctx.user) {
        throw new GraphQLError('You must be signed in.', {
          extensions: { code: 'UNAUTHENTICATED' },
        });
      }
      return ctx.user;
    },
  },
};

Errors array or data

One bad item, the rest still arrive

{
  products(skus: ["LAMP-01", "DESK-9", "BULB-07"]) { sku price }
}

What clients notice

Find breaking changes with graphql-js

import { buildSchema, findBreakingChanges, findDangerousChanges } from 'graphql';

const before = buildSchema(`
  type Query { order(id: ID!): Order }
  type Order { id: ID! status: Status! total: Float! note: String }
  enum Status { PENDING PAID }
`);
const after = buildSchema(`
  type Query { order(id: ID!, region: String!): Order }
  type Order { id: ID! status: Status! total: Int! }
  enum Status { PENDING PAID REFUNDED }
`);

for (const c of findBreakingChanges(before, after)) console.log('breaking ', c.type, c.description);
for (const c of findDangerousChanges(before, after)) console.log('dangerous', c.type, c.description);

The lifecycle of a field

type Product {
  stock: Int @deprecated(reason: "Use stockLevel. Removal planned after 2027-01-31.")
  stockLevel: Int
}

List the deprecated fields

{
  __type(name: "Product") {
    fields(includeDeprecated: true) {
      name
      isDeprecated
      deprecationReason
    }
  }
}

GET for queries

curl -s -G https://swapi-graphql.netlify.app/graphql --data-urlencode 'query={ film(filmID: 1) { title } }'

Mutations over GET are refused

mutation {
  createOrder(input: { customerId: "cus_42", items: [{ sku: "LAMP-01" }] }) { order { id } }
}

# method: GET

The Accept header decides 200 or 400

for a in application/json application/graphql-response+json; do
  curl -s -o /dev/null -w "$a -> %{http_code}\n" https://swapi-graphql.netlify.app/graphql -H "Content-Type: application/json" -H "Accept: $a" -d '{"query": "{ film(filmID: 1) { titel } }"}'
done

What servers send today and what the 2026 draft recommends

Multipart uploads and the alternative

Ask a type for its fields

{
  __type(name: "PageInfo") {
    kind
    fields {
      name
      type { kind name ofType { name } }
    }
  }
}

Download the schema as SDL

import { getIntrospectionQuery, buildClientSchema, printSchema } from 'graphql';

const res = await fetch('https://swapi-graphql.netlify.app/graphql', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ query: getIntrospectionQuery() }),
});
const { data } = await res.json();
const sdl = printSchema(buildClientSchema(data));
console.log(sdl.split('\n').length, 'lines');
console.log(sdl.slice(sdl.indexOf('type Film '), sdl.indexOf('type Film ') + 110));

Turn introspection off in production

import { ApolloServer } from '@apollo/server';
const apollo = new ApolloServer({ typeDefs, resolvers, introspection: process.env.NODE_ENV !== 'production' });

import { createYoga } from 'graphql-yoga';
import { useDisableIntrospection } from '@graphql-yoga/plugin-disable-introspection';
const yoga = createYoga({ schema, plugins: [useDisableIntrospection()] });

Which operations a server supports

{
  __schema {
    queryType { name }
    mutationType { name }
    subscriptionType { name }
  }
}

First page

query Orders($after: String) {
  orders(first: 2, after: $after) {
    totalCount
    edges { cursor node { id status } }
    pageInfo { hasNextPage endCursor }
  }
}

Next page

query Orders($after: String) {
  orders(first: 2, after: $after) {
    edges { node { id status } }
    pageInfo { hasNextPage endCursor }
  }
}

# variables: {"after": "b3JkZXI6b3JkXzg3OTA="}

The connection types

type OrderConnection {
  edges: [OrderEdge!]!
  pageInfo: PageInfo!
  totalCount: Int!
}

type OrderEdge {
  cursor: String!
  node: Order!
}

type PageInfo {
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
  endCursor: String
}

Cap page size on the server

{
  orders(first: 500) { totalCount }
}

Offset versus cursor

Send a hash, fall back to the full query

import { createHash } from 'node:crypto';
import { createYoga, createSchema } from 'graphql-yoga';
import { useAPQ } from '@graphql-yoga/plugin-apq';

const yoga = createYoga({
  schema: createSchema({ typeDefs: 'type Query { hello: String! }', resolvers: { Query: { hello: () => 'world' } } }),
  plugins: [useAPQ()],
  logging: false,
});

const query = '{ hello }';
const sha256Hash = createHash('sha256').update(query).digest('hex');
const extensions = JSON.stringify({ persistedQuery: { version: 1, sha256Hash } });
const get = async () => (await yoga.fetch('http://localhost/graphql?extensions=' + encodeURIComponent(extensions))).text();

console.log('1 GET hash only:', await get());
const post = await yoga.fetch('http://localhost/graphql', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ query, extensions: JSON.parse(extensions) }) });
console.log('2 POST query and hash:', await post.text());
console.log('3 GET hash only:', await get());

Allow only the operations your apps ship

Options that work with POST-heavy APIs

parent, args, context, info

const resolvers = {
  Query: {
    orders: (parent, args, context, info) => context.db.orders.list(args),
  },
  Order: {
    total: (order) => order.items.reduce((s, i) => s + i.price * i.qty, 0),
    customer: (order, _, ctx) => ctx.loaders.customer.load(order.customerId),
  },
};

Code-first types and a query

import strawberry

@strawberry.type
class Product:
    sku: str
    name: str
    price: float

PRODUCTS = [Product(sku="LAMP-01", name="Desk lamp", price=39.5), Product(sku="BULB-07", name="LED bulb", price=5.0)]

@strawberry.type
class Query:
    @strawberry.field
    def products(self, max_price: float | None = None) -> list[Product]:
        return [p for p in PRODUCTS if max_price is None or p.price <= max_price]

schema = strawberry.Schema(query=Query)
print(schema.as_str())
print(schema.execute_sync("{ products(maxPrice: 10) { sku name } }").data)

A complete server

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

const yoga = createYoga({
  schema: createSchema({
    typeDefs: 'type Query { hello(name: String = "world"): String! }',
    resolvers: { Query: { hello: (_, { name }) => `Hello, ${name}` } },
  }),
});

createServer(yoga).listen(4000, () => console.log('http://localhost:4000/graphql'));

Five orders, five customer queries, then one

import { graphql, buildSchema } from 'graphql';
import DataLoader from 'dataloader';

const schema = buildSchema(`
  type Query { orders: [Order!]! }
  type Order { id: ID! customer: Customer! }
  type Customer { id: ID! name: String! }
`);

const names = { c1: 'Ana', c2: 'Mihai' };
const orders = [['o1', 'c1'], ['o2', 'c2'], ['o3', 'c1'], ['o4', 'c2'], ['o5', 'c1']];
let sql = [];
const customersByIds = async (ids) => {
  sql.push(`SELECT * FROM customers WHERE id IN (${ids.map((i) => `'${i}'`).join(', ')})`);
  return ids.map((id) => ({ id, name: names[id] }));
};

const root = (load) => ({ orders: () => orders.map(([id, c]) => ({ id, customer: () => load(c) })) });
const source = '{ orders { id customer { name } } }';

await graphql({ schema, source, rootValue: root(async (id) => (await customersByIds([id]))[0]) });
console.log('without DataLoader:', sql.length, 'queries');

sql = [];
const loader = new DataLoader(customersByIds);
await graphql({ schema, source, rootValue: root((id) => loader.load(id)) });
console.log('with DataLoader:', sql.length, 'query');
console.log(sql[0]);

Get the details right

The common choice in each language

An annotated controller

@Controller
public class OrderController {

    private final OrderService orders;
    private final CustomerService customers;

    public OrderController(OrderService orders, CustomerService customers) {
        this.orders = orders;
        this.customers = customers;
    }

    @QueryMapping
    public Order order(@Argument String id) {
        return orders.find(id);
    }

    @BatchMapping
    public Map<Order, Customer> customer(List<Order> list) {
        return customers.forOrders(list);
    }
}

Standalone server

import { ApolloServer } from '@apollo/server';
import { startStandaloneServer } from '@apollo/server/standalone';

const server = new ApolloServer({ typeDefs, resolvers });
const { url } = await startStandaloneServer(server, {
  listen: { port: 4000 },
  context: async ({ req }) => ({ token: req.headers.authorization }),
});
console.log(url);

A depth limit as a validation rule

import { buildSchema, parse, validate, specifiedRules, GraphQLError, Kind } from 'graphql';

const schema = buildSchema(`
  type Query { customer(id: ID!): Customer }
  type Customer { name: String orders: [Order] }
  type Order { id: ID customer: Customer }
`);

const maxDepth = (limit) => (context) => ({
  OperationDefinition(op) {
    const depthOf = (set, seen) => Math.max(0, ...set.selections.map((s) => {
      if (s.kind === Kind.FRAGMENT_SPREAD) {
        const frag = seen.has(s.name.value) ? null : context.getFragment(s.name.value);
        return frag ? depthOf(frag.selectionSet, new Set([...seen, s.name.value])) : 0;
      }
      const own = s.kind === Kind.FIELD ? 1 : 0;
      return s.selectionSet ? own + depthOf(s.selectionSet, seen) : own;
    }));
    const depth = depthOf(op.selectionSet, new Set());
    if (depth > limit) context.reportError(new GraphQLError(`Query depth ${depth} exceeds the limit of ${limit}.`, { nodes: [op] }));
  },
});

const query = parse('{ customer(id: "cus_42") { orders { customer { orders { customer { orders { id } } } } } } }');
console.log(validate(schema, query, [...specifiedRules, maxDepth(5)]).map((e) => e.message));

Use a maintained package in production

One request, many attempts

mutation {
  a1: login(email: "ana@example.com", password: "123456") { token }
  a2: login(email: "ana@example.com", password: "password") { token }
  a3: login(email: "ana@example.com", password: "qwerty") { token }
}

Before a GraphQL API goes public

  ok depth, alias and cost limits on every operation
  ok maximum page size enforced in resolvers
  ok authorization checked in the business layer, per object, not only per endpoint
  ok introspection and field suggestions off for private APIs
  ok trusted documents for first-party clients
  ok CSRF: require Content-Type application/json or a custom header, never accept text/plain or form posts
  ok errors masked so stack traces and SQL never reach clients
  ok request size and timeout limits at the HTTP layer

Put the user in context

const yoga = createYoga({
  schema,
  context: async ({ request }) => {
    const header = request.headers.get('authorization') ?? '';
    const user = header.startsWith('Bearer ') ? await verifyToken(header.slice(7)) : null;
    return { user };
  },
});

Check access where the data is loaded

const resolvers = {
  Query: {
    node: async (_, { id }, { user, loaders }) => {
      const obj = await loaders.byGlobalId.load(id);
      return obj && canRead(user, obj) ? obj : null;
    },
  },
};

Declarative rules

A subgraph extends Product with reviews

import { ApolloServer } from '@apollo/server';
import { ApolloServerPluginInlineTraceDisabled } from '@apollo/server/plugin/disabled';
import { buildSubgraphSchema } from '@apollo/subgraph';
import { parse } from 'graphql';

const typeDefs = parse(`
  extend schema @link(url: "https://specs.apollo.dev/federation/v2.12", import: ["@key"])

  type Product @key(fields: "sku") {
    sku: String!
    reviewCount: Int!
  }
`);

const counts = { 'LAMP-01': 12, 'BULB-07': 3 };
const resolvers = {
  Product: { __resolveReference: (ref) => ({ sku: ref.sku, reviewCount: counts[ref.sku] ?? 0 }) },
};

const server = new ApolloServer({ schema: buildSubgraphSchema([{ typeDefs, resolvers }]), plugins: [ApolloServerPluginInlineTraceDisabled()] });
const res = await server.executeOperation({
  query: 'query ($r: [_Any!]!) { _entities(representations: $r) { ... on Product { sku reviewCount } } }',
  variables: { r: [{ __typename: 'Product', sku: 'LAMP-01' }, { __typename: 'Product', sku: 'BULB-07' }] },
});
console.log(JSON.stringify(res.body.singleResult.data, null, 2));

Federation or one server

No library needed

const res = await fetch('https://swapi-graphql.netlify.app/graphql', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', Accept: 'application/graphql-response+json, application/json' },
  body: JSON.stringify({
    query: 'query Film($id: ID!) { film(id: $id) { title director } }',
    variables: { id: 'ZmlsbXM6Mg==' },
  }),
});
const { data, errors } = await res.json();
if (errors) console.error(errors);
console.log(res.status, data.film);

React setup and a query

import { ApolloClient, HttpLink, InMemoryCache, gql } from '@apollo/client';
import { ApolloProvider, useQuery } from '@apollo/client/react';

const client = new ApolloClient({
  link: new HttpLink({ uri: '/graphql' }),
  cache: new InMemoryCache(),
});

const ORDER = gql`
  query Order($id: ID!) {
    node(id: $id) { id ... on Order { status total } }
  }
`;

function OrderStatus({ id }) {
  const { data, loading, error } = useQuery(ORDER, { variables: { id } });
  if (loading) return 'Loading';
  if (error) return error.message;
  return data.node.status;
}

What each one is good at

GraphQL Code Generator with the client preset

import type { CodegenConfig } from '@graphql-codegen/cli';

const config: CodegenConfig = {
  schema: 'https://swapi-graphql.netlify.app/graphql',
  documents: ['src/**/*.{ts,tsx}'],
  generates: {
    './src/gql/': { preset: 'client' },
  },
};

export default config;

What each tool is for

Call the server in-process

import assert from 'node:assert/strict';
import { yoga } from './shop.mjs';

async function execute(query, variables, headers = {}) {
  const res = await yoga.fetch('http://test/graphql', {
    method: 'POST',
    headers: { 'content-type': 'application/json', ...headers },
    body: JSON.stringify({ query, variables }),
  });
  return { status: res.status, body: await res.json() };
}

const order = await execute('query ($id: ID!) { node(id: $id) { ... on Order { status total } } }', { id: 'ord_8812' });
assert.equal(order.status, 200);
assert.deepEqual(order.body.data.node, { status: 'PAID', total: 49.5 });

const anonymous = await execute('{ me { name } }');
assert.equal(anonymous.body.errors[0].extensions.code, 'UNAUTHENTICATED');

const signedIn = await execute('{ me { name } }', undefined, { authorization: 'Bearer test' });
assert.equal(signedIn.body.data.me.name, 'Ana Pop');
console.log('3 operations tested, all assertions passed');

The same with Apollo Server

import assert from 'node:assert/strict';
import { ApolloServer } from '@apollo/server';

const server = new ApolloServer({
  typeDefs: 'type Query { hello(name: String!): String! }',
  resolvers: { Query: { hello: (_, { name }) => `Hello, ${name}` } },
});

const res = await server.executeOperation({ query: 'query ($n: String!) { hello(name: $n) }', variables: { n: 'Ana' } });
assert.equal(res.body.kind, 'single');
assert.equal(res.body.singleResult.data.hello, 'Hello, Ana');
console.log(JSON.stringify(res.body.singleResult));

Fake data that matches the schema

import { makeExecutableSchema } from '@graphql-tools/schema';
import { addMocksToSchema } from '@graphql-tools/mock';
import { graphql } from 'graphql';

const typeDefs = `
  type Query { orders: [Order!]! }
  type Order { id: ID! status: Status! total: Float! }
  enum Status { PENDING PAID }
`;

const schema = addMocksToSchema({
  schema: makeExecutableSchema({ typeDefs }),
  mocks: { Float: () => 49.5, ID: () => 'ord_1', Status: () => 'PAID' },
});

console.log(JSON.stringify(await graphql({ schema, source: '{ orders { id status total } }' })));

A practical split

The practical differences

Message and fix

Editions and drafts

Current releases checked on October 14, 2026