Introduction to Resolvers

• Definition: Resolvers are functions that generate a response for a GraphQL query or mutation. They act as a bridge between the GraphQL server and the data sources.
• Purpose: Resolvers provide the instructions for turning a GraphQL operation (query, mutation, or subscription) into data. They define how to fetch or modify the data exactly as the client requests.

Structure of a Resolver

• Basic Components: Each resolver in GraphQL is a function that optionally takes four arguments:

  1. root (or parent): The result from the previous level of the resolver chain.
  2. args: An object that contains all GraphQL arguments provided in the query.
  3. context: An object shared across all resolvers that executes for a particular query. It often contains per-request state such as authentication information.
  4. info: A field-specific information object useful for advanced cases like building dynamic queries.

• Example:

  
  const resolvers = {
    Query: {
      user: (parent, args, context, info) => {
        return context.dataSources.userAPI.getUserById(args.id);
      }
    }
  }
  
  

Resolver Mapping

• Mapping Resolvers to Schema: Each field in a GraphQL schema type is linked to a function.
• Handling Nested Data: Resolvers can be nested to handle complex data fetching, like fetching a user and their posts.

Writing Basic Resolvers

• For Queries: Fetch data based on the input arguments.

  
  Query: {
    posts: (parent, args, context) => context.db.getPosts(),
    post: (parent, { id }, context) => context.db.getPostById(id),
  }
  
  

• For Mutations: Perform actions to modify data and return the new state of the data.

  
  Mutation: {
    createPost: (parent, { post }, context) => context.db.createPost(post),
    deletePost: (parent, { id }, context) => context.db.deletePost(id),
  }
  
  

Resolving Enums

• Definition and Use: Enums are special scalar types that are restricted to a particular set of allowed values. They help ensure your application uses only predefined values.

• Resolver Behavior: Typically, enum values do not require special resolver functions; they are validated by the GraphQL server against the schema and returned directly.

• Example:

  const resolvers = {
  	POST_STATUS: {
      DRAFT: 'draft',
      PUBLISHED: 'live',
      INREVIEW: 'in-review'
    }
  }
  
  

Resolving Unions

• Definition and Use: A union is a type that can be one of several types. It's useful when an API can return objects that are not related to each other.

• Type Resolver: Essential for GraphQL to know what type each returned object is when it fetches a union.

  
  const resolvers = {
    SearchResult: {
      __resolveType(obj, context, info) {
        if(obj.title) {
          return 'Book';
        }
        if(obj.publicationDate) {
          return 'Magazine';
        }
        if(obj.firstName) {
          return 'Author';
        }
        return null; // Type resolution failed
      }
    }
  }