🎱

Customising BaseResolver

Overview

BaseResolver provides powerful capabilities for automatically generating GraphQL schemas and types at runtime.

Yet, there may be situations where you need to customise the behaviour of BaseResolver to suit your specific application requirements.

Overview of BaseResolver Customisation

BaseResolver is designed to be extensible, allowing you to add custom queries, mutations, and other functionality to your GraphQL API.

Customisation in BaseResolver typically involves modifying or extending the Resolver files associated with your entities.

Here are some common scenarios where you might need to customise BaseResolver:

  1. Implementing custom business logic: You may need to define custom queries or mutations to perform specific operations that are not covered by the automatically generated CRUD operations.
  2. Modifying the generated schema: You might want to tweak the generated GraphQL schema to add additional fields, modify field behaviour, or introduce custom types. This is especially true for modifying the input types.
  3. Enhancing error handling and validation: You can customise the error handling and validation logic in BaseResolver to align with your application's requirements and error response formats.

Next, let’s look at how you can add a custom query or mutation.

How to Add a Custom Query or Mutation

Custom queries and mutations can be defined in the Resolver file for each entity.

In this example, let's say we want to implement a custom query to fetch users based on their age.

We can define a custom query named usersByAge in the UserResolver file:

// UserResolver.js

import { createBaseResolver } from '@exogee/graphweaver';
import { AccessorParams, RestBackendProvider } from '@exogee/graphweaver-rest';
import { Resolver } from 'type-graphql';

import { User as RestUser } from '../../entities';
import { User } from './entity';

@Resolver((of) => User)
export class UserResolver extends createBaseResolver<User, RestUser>(
	User,
	new RestBackendProvider('User', {
  // ...other resolver methods...

  async usersByAge({ age }) {
    // Custom logic to fetch drivers by age
    // Implement your own code here
    return await fetchUsersByAge(age);
  }
}

In this example, we define the usersByAge query that takes an age argument. Inside the resolver method, you can implement your own logic to fetch users based on the provided age.

To use the custom query in your GraphQL API, you can include it in your GraphQL schema and make a request to it:

query {
  usersByAge(age: 30) {
    id
    firstName
    lastName
    age
  }
}

In this query, we're using the custom usersByAge query to fetch users with an age of 30. The response will include the ID, firstName, lastName, and age of the matching users.

Similarly, you can define custom mutations in the Resolver file to perform specific actions based on your application's requirements.

Conclusion

Customising Base Resolver allows you to tailor the behaviour of your GraphQL API to meet your specific application requirements.

By following the steps outlined in this guide and adhering to best practices, you can effectively customise BaseResolver and extend its functionality.

Remember that while customisation offers flexibility, it's essential to strike a balance between customisation and maintainability.

Excessive modifications or deviations from the core functionality of BaseResolver may make it harder to integrate future updates and maintain your codebase.

With the ability to customise BaseResolver, you can unlock the full potential of your GraphWeaver API and tailor it to suit your unique application needs.

Exogee