Design & Optimize GraphQL Schemas and Resolvers

This agent designs efficient GraphQL schemas, implements optimized resolvers, and solves complex query performance issues including N+1 problems. It starts with schema analysis - examining existing .graphql/.gql schema files and resolver implementations to understand current structure and pain points - and data model mapping, analyzing underlying databases, APIs, or services to understand entity relationships and cardinality.

Performance profiling identifies N+1 query problems by examining resolver patterns and query execution paths. Schema design creates type definitions with proper field relationships, input types, and custom scalars following GraphQL best practices. Resolver optimization implements efficient resolvers using DataLoader, batch loading, and query optimization techniques. Validation and testing creates query examples and performance benchmarks to confirm schema efficiency.

Guidelines followed throughout: single source of truth with clear type ownership and data-source mapping, DataLoader for all one-to-many and many-to-many relationships, query-complexity analysis and depth limiting, strong typing with proper nullable/non-nullable definitions, Relay-style cursor pagination for list fields, proper error types and field-level error handling, query-cost analysis and rate limiting for production schemas, clear field documentation and deprecation notices, backward-compatible schema evolution, and resolver-timing/query-analytics monitoring recommendations.

Deliverables include a complete schema definition (types with relationships), resolver implementations wired to DataLoader instances, DataLoader configuration for batched entity loading, and a performance analysis covering query complexity, N+1 identification and fixes, caching strategy, and database query optimization suggestions.

Use this agent when designing a new GraphQL API or fixing performance problems (especially N+1 queries) in an existing GraphQL schema and resolver layer. It is well suited to APIs with meaningful entity relationships where naive resolvers would cause repeated database hits. It is not meant for REST API design, or for GraphQL schemas so simple that N+1 and batching concerns don't apply.

Input: existing GraphQL schema files, resolver implementations, and the underlying data sources they query.

Output: a schema definition, DataLoader-backed resolver implementations, DataLoader configuration, and a performance analysis. Example resolver pattern using DataLoader:

const resolvers = {
  User: {
    posts: (parent, args, { postLoader }) => {
      return postLoader.loadByUserId(parent.id);
    }
  },
  Post: {
    author: (parent, args, { userLoader }) => {
      return userLoader.load(parent.authorId);
    }
  }
};

Works with GraphQL schema files (.graphql/.gql), DataLoader for batch loading, and the underlying databases/APIs/services the schema resolves against.

Backend engineers designing or optimizing GraphQL APIs, and teams debugging N+1 query performance problems who need DataLoader-based resolver fixes with benchmarked results.