GraphQL Development

Design efficient GraphQL APIs.

When to Use

• Creating GraphQL schemas

• Resolver implementation

• N+1 query problems

• Federation/stitching

• Performance optimization

Schema Design

type Query { user(id: ID!): User users(filter: UserFilter, limit: Int = 10): UserConnection! }

type Mutation { createUser(input: CreateUserInput!): CreateUserPayload! updateUser(id: ID!, input: UpdateUserInput!): UpdateUserPayload! }

type User { id: ID! email: String! name: String! posts(first: Int, after: String): PostConnection! createdAt: DateTime! }

input CreateUserInput { email: String! name: String! }

type CreateUserPayload { user: User errors: [Error!] }

type UserConnection { edges: [UserEdge!]! pageInfo: PageInfo! totalCount: Int! }

type UserEdge { node: User! cursor: String! }

type PageInfo { hasNextPage: Boolean! endCursor: String }

Resolvers

const resolvers = { Query: { user: (_, { id }, { dataSources }) => dataSources.users.getById(id),

users: async (_, { filter, limit }, { dataSources }) => {
  const users = await dataSources.users.find(filter, limit);
  return connectionFromArray(users);
},

},

User: { // Field resolver with DataLoader for N+1 posts: (user, args, { loaders }) => loaders.postsByUser.load(user.id), },

Mutation: { createUser: async (_, { input }, { dataSources }) => { try { const user = await dataSources.users.create(input); return { user, errors: null }; } catch (e) { return { user: null, errors: [{ message: e.message }] }; } }, }, };

DataLoader (N+1 Solution)

const DataLoader = require("dataloader");

const createLoaders = (dataSources) => ({ userById: new DataLoader(async (ids) => { const users = await dataSources.users.getByIds(ids); const userMap = new Map(users.map((u) => [u.id, u])); return ids.map((id) => userMap.get(id) || null); }),

postsByUser: new DataLoader(async (userIds) => { const posts = await dataSources.posts.findByUserIds(userIds); const grouped = groupBy(posts, "userId"); return userIds.map((id) => grouped[id] || []); }), });

Performance Tips

• Use DataLoader for batching

• Implement query complexity limits

• Add depth limiting

• Cache with Redis/CDN

• Use persisted queries

Best Practices

• Nullable by default, explicit ! for required

• Use input types for mutations

• Return payload types with errors

• Implement cursor pagination

• Version via schema evolution

Examples

Input: "Fix N+1 queries" Action: Implement DataLoader, batch database queries

Input: "Design user management API" Action: Create schema with types, queries, mutations, pagination