The New Age Axios Setup: Separation of Concerns in React

However, as applications grow in complexity, it becomes necessary to organize code and adopt best practices for maintainability, scalability, and readability. In this blog post, we will explore a separation of concerns approach in React using Axios. We will demonstrate how to structure your code by leveraging abstraction layering and modularization techniques.

But before we dive into the details, let's briefly discuss Axios and its benefits.

Understanding Axios

Axios is a popular JavaScript library that simplifies making HTTP requests. It provides an easy-to-use API for performing GET, POST, PUT, DELETE, and other types of HTTP requests. Axios supports promises, allowing you to handle asynchronous operations elegantly using async/await syntax.

Some key benefits of using Axios include:

Simplicity:

Axios provides a simple and intuitive API for making HTTP requests, making it easy to get started.

1. Promise-based: Axios leverages JavaScript promises, enabling you to handle asynchronous operations in a more readable and efficient manner.
2. Interceptors: Axios allows you to intercept requests and responses, enabling you to modify or handle them globally.

Now that we have a basic understanding of Axios let's explore how to structure your code using separation of concerns.

Separation of Concerns in React

Separation of concerns is a software design principle that encourages splitting a program into distinct sections, each responsible for a specific aspect of functionality. In the context of React applications, this principle helps in organizing code, improving code maintainability, and making it easier to understand and modify.

When using Axios in a React project, it's beneficial to separate the concerns related to API requests and data management from the components themselves. This separation promotes code reusability, modularity, and testability.

To achieve this, we can follow a three-layered architecture consisting of:

Service Layer

The service layer encapsulates the logic for making API requests using Axios. It abstracts away the details of API endpoints, request configurations, and error handling. This layer allows us to centralize API-related code and reuse it throughout the application.

Here's an example of how a service layer using Axios can be implemented:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import axios from 'axios';

const API_BASE_URL = 'https://your.api-base.url'; // Replace with your actual API base URL

// Fetch users from the API
export const fetchUsers = async () => {
  try {
    const response = await axios.get(`${API_BASE_URL}/users`);
    return response; // This will include the response data, status, and other information
  } catch (error) {
    // Handle or throw the error as needed
    console.error('Error fetching users:', error);
    throw error;
  }
};

// Create a new user in the API
export const createUser = async (user) => {
  try {
    const response = await axios.post(`${API_BASE_URL}/users`, user);
    return response; // This will include the response data, status, and other information
  } catch (error) {
    // Handle or throw the error as needed
    console.error('Error creating user:', error);
    throw error;
  }
};

// Other API service methods...

By centralizing API logic in the service layer, we can easily reuse these methods throughout the application, avoiding duplication and promoting code consistency.

Data Layer

The data layer acts as an intermediary between the components and the service layer. Its primary responsibility is to manage data retrieval, transformation, and caching.

In this layer, we consume the API service methods from the service layer and adapt the responses to suit the needs of our components. Additionally, we can implement caching strategies or handle complex data transformations specific to our application requirements.

Here's an example of a data layer module that interacts with the service layer:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
         // userData.js
        import { fetchUsers, createUser } from './apiService';
    
        export const getUsers = async () => {
          try {
            const response = await fetchUsers();
            return response.data;
          } catch (error) {
            // Handle error...
          }
        };
    
        export const addUser = async (user) => {
          try {
            const response = await createUser(user);
            return response.data;
          } catch (error) {
            // Handle error...
          }
        };
    
        // Other data layer methods...
       

In this example, we consume the fetchUsers and createUser methods from the service layer and return the transformed data to the components. We handle any potential errors within the data layer, allowing the components to focus solely on rendering and user interactions.

Component Layer

The component layer is responsible for rendering the UI and handling user interactions. It consumes data from the data layer and updates the data when required.

Components should be kept as lean as possible, with minimal business logic. They should mainly focus on rendering the UI, handling user input, and triggering actions when necessary.

Here's an example of how a component can consume data from the data layer:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
         import React, { useEffect, useState } from 'react';
        import { getUsers, addUser } from './userData';
    
        const UserList = () => {
          const [users, setUsers] = useState([]);
    
          useEffect(() => {
            const fetchUsersData = async () => {
              const usersData = await getUsers();
              setUsers(usersData);
            };
    
            fetchUsersData();
          }, []);
    
          const handleAddUser = async (user) => {
            await addUser(user);
            // Refresh the user list or perform other actions...
          };
    
          return (
            <div>
              <ul>
                {users.map((user) => (
                  <li key={user.id}>{user.name}</li>
                ))}
              </ul>
              <button onClick={() => handleAddUser({ name: 'John' })}>
                Add User
              </button>
            </div>
          );
        };
    
        export default UserList;
       

‍

In this example, the UserList component uses the getUsers function from the data layer to fetch a list of users. It then renders the list of users and provides a button to add a new user, which calls the addUser function from the data layer.

By separating concerns and following the three-layered architecture, we achieve cleaner, more maintainable, and testable code. Changes to the API service or data layer won't affect the components, making it easier to refactor and scale the application.

Best Practices for Using Axios in React

Now that we have established the three-layered architecture and separation of concerns, let's delve deeper into some best practices and techniques for using Axios in your React applications.

1. Handling Post Requests with Axios

In modern web applications, making POST requests is a common requirement for sending data to the server. Axios makes it straightforward to handle POST requests using its post method.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
         import axios from 'axios';
    
        const postData = async () => {
          const data = { name: 'John', email: 'john@example.com' };
    
          try {
            const response = await axios.post('https://api.example.com/users', data);
            console.log(response.data); // Data returned by the server after successful POST
          } catch (error) {
            console.error(error);
          }
        };
       

‍

In this example, we use Axios to send a POST request to the server with the data object as the request payload. The post method returns a promise, and we use await to handle the asynchronous response.

2. Importing Axios in React Components

To use Axios in your React components, you need to import it. Make sure you have installed Axios as a dependency in your project before importing it.

Copy
1
2
3
4
5
6
7
         import React, { useEffect, useState } from 'react';
        import axios from 'axios';
    
        const ComponentName = () => {
          // Component logic...
        };
       

By importing Axios directly into the components where you need it, you ensure that each component can handle its own data requests independently.

3. Using Async/Await for Asynchronous Operations

To leverage the full power of Axios, take advantage of JavaScript's async/await syntax when making API requests. This allows you to write cleaner and more readable code for handling asynchronous operations.

Copy
1
2
3
4
5
6
7
8
9
10
11
         import axios from 'axios';
    
        const fetchData = async () => {
          try {
            const response = await axios.get('https://api.example.com/data');
            console.log(response.data); // Process the data returned by the API
          } catch (error) {
            console.error(error);
          }
        };
       

‍

By using async/await, you can avoid callback hell and write synchronous-looking code while still handling asynchronous operations gracefully.

4. Creating Custom Axios Instances

Axios allows you to create custom instances with specific configurations. This can be beneficial when you need different base URLs or headers for different parts of your application.

Copy
1
2
3
4
5
6
7
8
9
10
         import axios from 'axios';
    
        const customAxios = axios.create({
          baseURL: 'https://api.example.com',
          timeout: 5000,
          headers: { 'Authorization': 'Bearer YOUR_ACCESS_TOKEN' },
        });
    
        export default customAxios;
       

‍

With this custom instance, you can use the customAxios object to perform API requests, and it will automatically use the specified configuration.

5. Interceptors for Global Request and Response Handling

Axios allows you to intercept requests and responses using interceptors. This is useful for performing actions like adding headers to all requests or handling errors globally.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
         import axios from 'axios';
    
        // Request interceptor
        axios.interceptors.request.use(
          (config) => {
            // Modify config before sending the request
            config.headers['Authorization'] = 'Bearer YOUR_ACCESS_TOKEN';
            return config;
          },
          (error) => {
            // Handle request error
            return Promise.reject(error);
          }
        );
    
        // Response interceptor
        axios.interceptors.response.use(
          (response) => {
            // Modify response data before passing it to the calling function
            return response.data;
          },
          (error) => {
            // Handle response error
            return Promise.reject(error);
          }
        );
       

With interceptors, you can perform actions like adding authentication headers or handling common errors across all API requests.

6. Error Handling with Axios

Axios provides specific error objects for different types of errors that can occur during an API request. Handle errors gracefully to provide a better user experience.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
         import axios from 'axios';
    
        const fetchData = async () => {
          try {
            const response = await axios.get('https://api.example.com/data');
            console.log(response.data);
          } catch (error) {
            if (error.response) {
              // The request was made, but the server responded with a non-2xx status code
              console.error(error.response.data);
              console.error(error.response.status);
              console.error(error.response.headers);
            } else if (error.request) {
              // The request was made, but no response was received
              console.error(error.request);
            } else {
              // Something happened in setting up the request that triggered an Error
              console.error('Error', error.message);
            }
            console.error(error.config);
          }
        };
       

‍

By differentiating between different error types, you can provide more informative error messages and handle issues appropriately.

7. Handling Request Cancellation

In some cases, you might want to cancel an ongoing API request, especially if the user navigates away from a component before the request is completed. Axios supports request cancellation using the CancelToken.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
         import axios from 'axios';
    
        const source = axios.CancelToken.source();
    
        const fetchData = async () => {
          try {
            const response = await axios.get('https://api.example.com/data', {
              cancelToken: source.token,
            });
            console.log(response.data);
          } catch (error) {
            if (axios.isCancel(error)) {
              console.log('Request canceled:', error.message);
            } else {
              console.error('Error', error.message);
            }
          }
        };
    
        // Cancel the request
        source.cancel('Operation canceled by the user.');
       

‍

By canceling ongoing requests, you can prevent unnecessary data fetching and improve the performance of your application.

8. Properly Cleaning Up Effects

In React, when using useEffect for making API requests or other side effects, it's essential to clean up after the component is unmounted. Otherwise, it may lead to memory leaks or unexpected behavior.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
         import React, { useState, useEffect } from 'react';
        import axios from 'axios';
    
        const ComponentName = () => {
          const [data, setData] = useState([]);
    
          useEffect(() => {
            let isMounted = true;
    
            const fetchData = async () => {
              try {
                const response = await axios.get('https://api.example.com/data');
                if (isMounted) {
                  setData(response.data);
                }
              } catch (error) {
                console.error(error);
              }
            };
    
            fetchData();
    
            return () => {
              // Clean up on unmount
              isMounted = false;
            };
          }, []);
    
          return <div>{/* Render component content */}</div>;
        };
    
        export default ComponentName;
       

By using the isMounted variable, we ensure that the state is only updated when the component is still mounted, preventing potential memory leaks.

9. Testing Axios Calls with Mocks

While testing React components that use Axios, you may want to mock the API calls to isolate component testing from external dependencies.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
         import React from 'react';
        import { render, act } from '@testing-library/react';
        import axios from 'axios';
        import ComponentName from './ComponentName';
    
        jest.mock('axios');
    
        test('renders component and handles API response', async () => {
          const mockResponse = {
            data: [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }],
          };
          axios.get.mockResolvedValueOnce(mockResponse);
    
          let container;
          await act(async () => {
            const { container: componentContainer } = render(<ComponentName />);
            container = componentContainer;
          });
    
          // Perform assertions on the rendered container or component
        });
       

By using jest.mock('axios'), we mock the Axios module, and by using axios.get.mockResolvedValueOnce, we set the mock response for the API call. This way, the component can be tested without making actual API requests.

10. Managing Axios Instances with Custom Hooks

To further enhance code modularity and reusability, you can create custom hooks that wrap Axios calls and manage the API logic.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
         import { useState, useEffect } from 'react';
        import axios from 'axios';
    
        const useAxios = (url) => {
          const [data, setData] = useState([]);
          const [loading, setLoading] = useState(true);
          const [error, setError] = useState(null);
    
          useEffect(() => {
            let isMounted = true;
    
            const fetchData = async () => {
              try {
                const response = await axios.get(url);
                if (isMounted) {
                  setData(response.data);
                }
              } catch (error) {
                setError(error);
              } finally {
                setLoading(false);
              }
            };
    
            fetchData();
    
            return () => {
              isMounted = false;
            };
          }, [url]);
    
          return { data, loading, error };
        };
    
        export default useAxios;
       

With this custom hook, you can easily reuse the API call logic in multiple components, reducing redundancy and promoting code consistency.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
         import React from 'react';
        import useAxios from './useAxios';
    
        const ComponentName = () => {
          const { data, loading, error } = useAxios('https://api.example.com/data');
    
          if (loading) {
            return <div>Loading...</div>;
          }
    
          if (error) {
            return <div>Error: {error.message}</div>;
          }
    
          return <div>{/* Render component content using 'data' */}</div>;
        };
    
        export default ComponentName;
       

By leveraging custom hooks, you can create a reusable interface for making API requests and handling responses.

Introducing WiseGPT

While Axios provides an excellent foundation for handling API requests, it's worth exploring additional tools and libraries that can enhance your development experience. One such tool is WiseGPT, a plugin for generating code for APIs directly into your React project.

WiseGPT offers several key benefits:

1. No Limit on Output Size: With WiseGPT, you can generate code for APIs of any size, accommodating large-scale projects with ease.
2. Mirrors Your Coding Style: WiseGPT generates code that matches your coding style, ensuring consistency and familiarity throughout your codebase.
3. Promptless: Unlike traditional AI models, WiseGPT does not require prompts. It understands the context of your code and generates relevant code snippets accordingly.
4. Auto-Created Models and Functions: WiseGPT automatically creates models and functions based on the provided collection of APIs, reducing manual effort and speeding up development.

With WiseGPT, you can eliminate the manual process of making API requests, parsing responses, and managing error handling for complex API endpoints. WiseGPT takes care of all these aspects, allowing you to focus on building features and delivering value to users.

To get started with WiseGPT, provide your collection of APIs, and let WiseGPT generate the necessary code for handling API requests. It seamlessly integrates with your React project, helping you save time and effort.

Conclusion

In this blog post, we explored the concept of separation of concerns in React applications, focusing on the use of Axios for handling API requests. By adopting a three-layered architecture, we can achieve cleaner, more modular, and maintainable code.

We discussed the service layer, data layer, and component layer, explaining their respective responsibilities and interactions. Separating concerns helps improve code organization, code reusability, and testability.

Additionally, we introduced WiseGPT, a powerful tool for generating code for APIs directly into your React project. With WiseGPT, you can streamline API-related code generation, eliminate manual tasks, and improve overall development productivity.

To experience the benefits of WiseGPT for yourself, give it a try and see how it can accelerate your React development process.

Remember, embracing separation of concerns and leveraging tools like WiseGPT can help you build robust and scalable React applications while keeping your codebase clean and maintainable. Happy coding!

Link to WiseGPTIn modern web development, handling API requests and managing data flows between components are essential tasks. One popular library that simplifies this process is Axios. It provides an elegant and straightforward way to make HTTP requests from a client application.