Interesting features of GraphQL

Hi, I am Arsen, one of the backend developers of BeeWeb. 👋 Today I have decided to talk about some interesting features of GraphQL.

If you are a backend developer, you are already familiar with GraphQL and its basics for sure. However, there are some lesser-known features and advanced techniques that you may not be well-aware of and will probably find useful. So, let’s have a look at some of them.

✔ Custom Directives

One of the most powerful and flexible features of GraphQL is its support for custom directives. Directives are annotations that can be added to fields, arguments and even entire operations in a GraphQL query. They allow you to add custom behavior to your schema without having to modify the underlying data model.

For example, you can define a custom @auth directive that checks whether a user is authorized to access a particular field. Or you can define a @cache directive that tells the server to cache the result of a query for a certain amount of time.

To define a custom directive in GraphQL, you simply need to add a new directive definition to your schema:

directive @auth(roles: [String]) on FIELD_DEFINITION

directive @cache(seconds: Int) on FIELD_DEFINITION

Then, you can add these directives to your query or mutation.

query {

suites @auth(roles: ["admin", "editor"] {

   id

   title

   orgId

  }
}


query {

projects @cache(seconds: 60) {

   id

   title

   suiteId

  }
}

✔ Batched Resolvers

In some cases, you may need to resolve multiple fields in a GraphQL query that are related to each other. For example, you may have a query that fetches a user’s profile and the list of their posts. Instead of making separate API calls for each field, you can use batched resolvers to fetch all the data in a single request.

Batched resolvers are resolvers that can return an array of promises instead of a single promise. GraphQL will automatically wait for all the promises to resolve before returning the response to the client.

Here’s an example of how you can implement a batched resolver for a user’s profile and posts.

const resolvers=

User:  {

  profileAndPosts: async (user, _, { dataSources  }) => {

     const [profile, posts ] = await Promise.all ( [

       dataSources.profileAPI.getProfile(user.id),

       dataSources.postAPI.getPostsByUser(user.id),

    ]);

    return  { profile, posts  };

    },

  },

},

Then, you can use this resolver in your schema.

type User{ 

   id: ID!

    name: String!

    profileAndPosts: ProfileAndPosts!

}


type ProfileAndPosts{

 profile: Profile!

 posts:  [Post!]!

}

type Query {

   user(id: ID!) User

}

Now, when you query for a user and their profile and posts, GraphQL will automatically batch the requests for the profile and posts into a single API call.

✔ Federation

As a backend developer, you can work on large microservice-based architectures where each service has its own database and API. GraphQL federation allows you to build a distributed API by combining multiple GraphQL services into a single schema. Each service is responsible for a specific domain or data source, and the federation layer acts as a gateway that routes requests to the appropriate service.

By using federation, you can expose a unified API to your clients without having to merge all your services into a single monolithic API. This can make it easier to manage and scale your backend architecture over time.

To use federation, you need to define a schema for each service that includes special @key directives that specify how entities in the schema are related to each other. Once you’ve defined your schemas, you can use a federation gateway to route requests to the appropriate service based on the @key directives.

In conclusion, GraphQL is a powerful and flexible technology that offers many advanced features and techniques that can help you build better APIs, some of which I presented in my blog post. By taking advantage of these features, you can make your backend architecture more scalable, performant, and maintainable over time. 🙌