This content originally appeared on DEV Community and was authored by Ayo Ashiru
In the previous article, Simplifying HTTP Requests in React with Custom Hooks 🎣, we explored how to simplify HTTP requests using custom hooks. While effective for smaller applications, this approach may become harder to maintain as your React app scales. In this article, we'll dive into how to handle CRUD (Create, Read, Update, Delete) operations in a scalable way using Axios and React Query.
Why Axios and React Query?
Axios: A promise-based HTTP client for the browser and Node.js, Axios simplifies sending asynchronous HTTP requests to REST endpoints with clean, readable code.
React Query: A powerful data-fetching library that enhances data synchronization, caching, and state management in React. React Query automates data fetching while providing better control over loading and error states.
Setting Up Axios and React Query
First, install the necessary packages:
npm install axios react-query react-router-dom
Setting Up React Query in Your App
Next, configure React Query in your entry file (App.tsx) to manage your application's global query settings.
// src/App.tsx
import { QueryClient, QueryClientProvider } from 'react-query';
import { CustomRouter } from './Router';
const queryClient = new QueryClient({
defaultOptions: {
queries: {
refetchOnWindowFocus: false, // Prevent refetch on tab/window switch
retry: 1, // Retry failed queries once
},
},
});
const App: React.FC = () => (
<QueryClientProvider client={queryClient}>
<CustomRouter />
</QueryClientProvider>
);
export default App;
Setting Up Axios with Interceptors
To handle authentication globally, we can create an Axios instance and use interceptors to attach the Authorization header for authenticated requests.
// src/config/axiosApi.ts
import axios from 'axios';
const authenticatedApi = axios.create({
baseURL: import.meta.env.VITE_BASE_URL, // Environment-specific base URL
headers: {
'Content-Type': 'application/json',
},
});
// Attach Authorization token to requests if present
authenticatedApi.interceptors.request.use((config) => {
const token = localStorage.getItem('crud-app-auth-token');
if (token) {
config.headers.Authorization = `Bearer ${token}`;
}
return config;
});
export { authenticatedApi };
Creating API Functions for CRUD Operations
Let's define functions that interact with our API to perform CRUD operations using Axios:
// src/data/api/post.ts
import { authenticatedApi } from '../../config/axiosApi';
// Error handler function to standardize error messages
export const handleApiError = (error: any): never => {
if (error.message === 'Network Error') {
throw new Error('Network Error. Please try again later.');
} else if (error.response?.data?.error) {
throw new Error(error.response.data.error);
} else if (error.response) {
throw new Error('A server error occurred.');
} else {
throw new Error(error.message || 'An unknown error occurred.');
}
};
// General function to handle API requests
export const apiCall = async <T>(
method: 'get' | 'post' | 'put' | 'delete',
url: string,
data?: any,
): Promise<T> => {
try {
const response = await authenticatedApi[method](url, data);
return response.data;
} catch (error) {
throw handleApiError(error);
}
};
// CRUD functions for the post feed
export const createPostApi = (post: any) => apiCall<any>('post', 'posts', post);
export const getPostsApi = () => apiCall<any>('get', 'posts');
export const updatePostApi = (id: string, post: any) => apiCall<any>('put', `posts/${id}`, post);
export const deletePostApi = (id: string) => apiCall<any>('delete', `posts/${id}`);
Using React Query Hooks for CRUD Operations
Now that we have API functions, we can use React Query to handle state management and data fetching for these operations.
// src/data/hooks/post.ts
import { useMutation, useQuery, useQueryClient } from 'react-query';
import { createPostApi, getPostsApi, updatePostApi, deletePostApi } from '../api/post';
// Custom hooks for CRUD operations
export const useCreatePostApi = () => {
const queryClient = useQueryClient();
return useMutation(createPostApi, {
onSuccess: () => queryClient.invalidateQueries(['posts']), // Refetch posts after a new post is created
});
};
export const useGetPostsApi = () => useQuery(['posts'], getPostsApi);
export const useUpdatePostApi = () => {
const queryClient = useQueryClient();
return useMutation(updatePostApi, {
onSuccess: () => queryClient.invalidateQueries(['posts']), // Refetch posts after an update
});
};
export const useDeletePostApi = () => {
const queryClient = useQueryClient();
return useMutation(deletePostApi, {
onSuccess: () => queryClient.invalidateQueries(['posts']), // Refetch posts after deletion
});
};
Consuming CRUD Hooks in a Component
Finally, we can build a simple component that consumes the custom hooks and allows users to create, edit, and delete posts.
// src/components/PostCard.tsx
import React, { useState } from 'react';
import { useGetPostsApi, useDeletePostApi, useUpdatePostApi, useCreatePostApi } from '../data/hooks/post';
import { toast } from '../components/Toast'; // Assume a toast component exists
const PostCard: React.FC = () => {
const { data: posts, isLoading, error } = useGetPostsApi();
const deletePost = useDeletePostApi();
const updatePost = useUpdatePostApi();
const createPost = useCreatePostApi();
const [newPost, setNewPost] = useState({ title: '', content: '' });
const handleCreate = async () => {
try {
await createPost.mutateAsync(newPost);
setNewPost({ title: '', content: '' });
toast.success('Post created successfully');
} catch (error) {
toast.error(error.message);
}
};
const handleDelete = async (id: string) => {
try {
await deletePost.mutateAsync(id);
toast.success('Post deleted successfully');
} catch (error) {
toast.error(error.message);
}
};
const handleEdit = async (id: string, updatedPost: any) => {
try {
await updatePost.mutateAsync({ id, ...updatedPost });
toast.success('Post updated successfully');
} catch (error) {
toast.error(error.message);
}
};
if (isLoading) return <div>Loading...</div>;
if (error) return <div>Error: {error.message}</div>;
return (
<div>
<div>
<input
type="text"
value={newPost.title}
onChange={(e) => setNewPost({ ...newPost, title: e.target.value })}
placeholder="Title"
/>
<input
type="text"
value={newPost.content}
onChange={(e) => setNewPost({ ...newPost, content: e.target.value })}
placeholder="Content"
/>
<button onClick={handleCreate} disabled={createPost.isLoading}>
{createPost.isLoading ? 'Creating...' : 'Create Post'}
</button>
</div>
{posts?.map((post: any) => (
<div key={post.id}>
<h3>{post.title}</h3>
<p>{post.content}</p>
<button onClick={() => handleEdit(post.id, { title: 'Updated Title', content: 'Updated Content' })}>
Edit
</button>
<button onClick={() => handleDelete(post.id)}>
Delete
</button>
</div>
))}
</div>
);
};
export default PostCard;
Conclusion
By using Axios and React Query, you can streamline CRUD operations in your React applications. This combination results in clean, maintainable code, improving scalability and performance. Use these tools to simplify state management and data fetching as your app grows.
For more insights on React, TypeScript, and modern web development practices, follow me on Dev.to! 👨💻
This content originally appeared on DEV Community and was authored by Ayo Ashiru
Ayo Ashiru | Sciencx (2024-09-24T12:16:01+00:00) React CRUD Operations with Axios and React Query. Retrieved from https://www.scien.cx/2024/09/24/react-crud-operations-with-axios-and-react-query-2/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.