GraphQL: Schema, Queries and Resolvers Reference Guide

# Server picks
npm install @apollo/server graphql                # Apollo Server (most popular)
npm install graphql-yoga                          # smaller, modular alternative
npm install pothos-graphql graphql @pothos/core   # code-first schema (TS)

# Python / FastAPI
pip install strawberry-graphql[fastapi]

# Client picks
npm install @apollo/client graphql                # full-featured cache
npm install graphql-request                       # minimal fetch wrapper
npm install urql                                  # smaller, exchange-based

# Dev tooling
npm install -D graphql-codegen-cli @graphql-codegen/typescript
npx graphql-codegen init                           # generate TS types from schema

# Schema Definition Language (SDL)
scalar DateTime

"""A blog post."""
type Post {
  id:        ID!
  title:     String!
  body:      String!
  status:    PostStatus!
  author:    User!
  tags:      [Tag!]!
  createdAt: DateTime!
}

enum PostStatus { DRAFT PUBLISHED ARCHIVED }

interface Node { id: ID! }
type User implements Node {
  id:    ID!
  name:  String!
  posts(first: Int = 10): PostConnection!
}

union SearchResult = Post | User

input CreatePostInput {
  title: String!
  body:  String!
  tags:  [String!] = []
}

type Query {
  post(id: ID!): Post
  posts(status: PostStatus, first: Int = 20, after: String): PostConnection!
}

type Mutation {
  createPost(input: CreatePostInput!): Post!
}

type Subscription {
  postPublished: Post!
}

// Apollo Server resolvers map 1:1 to schema fields
import { ApolloServer } from "@apollo/server";
import { startStandaloneServer } from "@apollo/server/standalone";
import DataLoader from "dataloader";

const typeDefs = /* GraphQL */ `
  type Post  { id: ID!, title: String!, author: User! }
  type User  { id: ID!, name: String! }
  type Query { posts: [Post!]! }
`;

const resolvers = {
  Query: {
    posts: (_: unknown, _args: unknown, ctx: Ctx) => ctx.db.posts.all(),
  },
  Post: {
    // Per-row author lookup batched by DataLoader -> no N+1
    author: (post, _args, ctx: Ctx) => ctx.loaders.user.load(post.authorId),
  },
};

type Ctx = { db: DB; loaders: { user: DataLoader } };

const server = new ApolloServer({ typeDefs, resolvers });
await startStandaloneServer(server, {
  context: async () => ({
    db,
    loaders: {
      user: new DataLoader(async (ids) => db.users.byIds(ids as string[])),
    },
  }),
});

// Apollo Client — typical query + mutation hook
import { ApolloClient, InMemoryCache, gql, useQuery, useMutation } from "@apollo/client";

export const client = new ApolloClient({
  uri: "/graphql",
  cache: new InMemoryCache({
    typePolicies: {
      User: { keyFields: ["id"] },
      Query: { fields: { posts: { keyArgs: ["status"] } } },   // for pagination merge
    },
  }),
});

const POSTS = gql`
  query Posts($status: PostStatus) {
    posts(status: $status) {
      edges { node { id title } cursor }
      pageInfo { hasNextPage endCursor }
    }
  }
`;
const CREATE_POST = gql`
  mutation Create($input: CreatePostInput!) { createPost(input: $input) { id title } }
`;

function PostList() {
  const { data, loading, fetchMore } =
    useQuery(POSTS, { variables: { status: "PUBLISHED" } });
  const [createPost] = useMutation(CREATE_POST, { refetchQueries: [POSTS] });
  // ...
}

// End-to-end: schema -> resolvers -> server -> hand-rolled client fetch.
import { ApolloServer } from "@apollo/server";
import { startStandaloneServer } from "@apollo/server/standalone";

const typeDefs = /* GraphQL */ `
  type Note { id: ID! body: String! }
  type Query    { notes: [Note!]! }
  type Mutation { addNote(body: String!): Note! }
`;

const notes: { id: string; body: string }[] = [];
const resolvers = {
  Query:    { notes: () => notes },
  Mutation: {
    addNote: (_: unknown, { body }: { body: string }) => {
      const n = { id: crypto.randomUUID(), body };
      notes.push(n); return n;
    },
  },
};

const server = new ApolloServer({ typeDefs, resolvers });
const { url } = await startStandaloneServer(server, { listen: { port: 4000 } });
console.log(`GraphQL at ${url}`);

// Hand-rolled client (no library)
const res = await fetch(url, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    query: `mutation($b: String!) { addNote(body: $b) { id body } }`,
    variables: { b: "hello" },
  }),
});
const { data, errors } = await res.json();