Server Actions in Next.js: Handling Mutations Without API Routes

Table of Contents

1. Introduction
2. What are Server Actions?
3. How Server Actions Work in Next.js
4. Creating Server Actions
5. Handling Mutations Without API Routes
6. Example: Server Action for Form Submission
7. Benefits of Using Server Actions
8. Error Handling in Server Actions
9. Best Practices for Server Actions
10. Conclusion

1. Introduction

In traditional React applications, handling mutations such as form submissions, database updates, or external API interactions often requires an API route or client-server communication. However, with Next.js 13+, Server Actions provide a more elegant and streamlined way to handle such mutations directly on the server without needing separate API routes.

Server Actions allow developers to define server-side logic directly within their components, keeping the codebase clean and concise, and providing a more seamless experience for handling mutations and other backend operations. This module will introduce you to Server Actions in Next.js, show how they work, and explain how you can use them to handle mutations efficiently.

2. What are Server Actions?

Server Actions are a feature introduced in Next.js 13+ that allows you to run server-side code directly within your components or functions, without the need to define separate API routes. This eliminates the need for additional boilerplate code and simplifies the flow between the frontend and backend.

With Server Actions, you can perform backend operations such as:

• Database mutations (create, update, delete)
• External API calls
• Form submissions

Server Actions are executed on the server but can be invoked from the client seamlessly. They offer a more intuitive way to manage backend functionality, especially when dealing with forms or user interactions.

3. How Server Actions Work in Next.js

Server Actions are tightly integrated with the App Router and are executed server-side, ensuring that the logic is handled by the server when the action is triggered.

Here’s how Server Actions typically work:

1. Server-Side Execution: Server Actions are defined within your Next.js components or pages and are executed on the server when called from the client.
2. Triggering the Action: The client can trigger these actions using React hooks (like useState or useEffect), passing the required data to the server.
3. No API Routes Needed: Unlike traditional Next.js, where you would create API routes (e.g., pages/api), Server Actions eliminate the need for these API routes, streamlining the code and avoiding additional file structures.

The main advantage of Server Actions is that you can define them directly in your components or layouts, keeping everything within the same context.

4. Creating Server Actions

In Next.js, creating a Server Action is simple and is done using an async function. These functions can be defined inside your components and can perform asynchronous tasks like fetching data, interacting with a database, or calling an API.

Example of a Server Action:

tsxCopyEdit// serverAction.ts
"use server";

async function saveFormData(data: { name: string; email: string }) {
  const response = await fetch("https://api.example.com/submit", {
    method: "POST",
    body: JSON.stringify(data),
    headers: {
      "Content-Type": "application/json",
    },
  });
  return response.json();
}

In this example, saveFormData is a Server Action that sends the form data to an external API when called.

Notice the "use server" directive at the top of the function. This tells Next.js that this function should be executed on the server side.

5. Handling Mutations Without API Routes

Mutations (e.g., creating, updating, or deleting data) usually require a separate API route. However, Server Actions eliminate the need for API routes for most common cases. You can call Server Actions directly from your components without worrying about managing additional server endpoints.

Example: Form Submission Using a Server Action

Let’s walk through an example of handling form submission using Server Actions in Next.js.

1. Client-side component to handle form submission:

tsxCopyEdit"use client";

import { useState } from "react";

export default function ContactForm() {
  const [formData, setFormData] = useState({ name: "", email: "" });
  const [status, setStatus] = useState("");

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    setStatus("Submitting...");

    try {
      await saveFormData(formData); // Server action call
      setStatus("Form submitted successfully!");
    } catch (error) {
      setStatus("Error submitting the form.");
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <input
        type="text"
        value={formData.name}
        onChange={(e) => setFormData({ ...formData, name: e.target.value })}
        placeholder="Name"
      />
      <input
        type="email"
        value={formData.email}
        onChange={(e) => setFormData({ ...formData, email: e.target.value })}
        placeholder="Email"
      />
      <button type="submit">Submit</button>
      <p>{status}</p>
    </form>
  );
}

In this form, we define a saveFormData function that directly calls the Server Action defined earlier. We don’t need an API route, and the form submission is handled server-side.

2. Server action to handle the form data:

tsxCopyEdit// serverActions.ts
"use server";

async function saveFormData(data: { name: string; email: string }) {
  const res = await fetch("https://api.example.com/form", {
    method: "POST",
    body: JSON.stringify(data),
    headers: {
      "Content-Type": "application/json",
    },
  });
  return res.json();
}

6. Example: Server Action for Form Submission

In the previous example, we used saveFormData to submit the form data to an external API. The Server Action saveFormData is used directly in the component to handle the mutation without the need for an API route.

This simplicity is one of the main advantages of Server Actions in Next.js. There’s no need to create a separate API route file, and the entire flow of handling form submissions or other mutations is encapsulated directly in the page component.

7. Benefits of Using Server Actions

Server Actions offer several benefits:

1. No Extra API Routes: You no longer need to create separate API route files for handling mutations. Everything is handled within the component, simplifying the structure of your app.
2. Seamless Server-Side Logic: Server Actions allow you to easily manage server-side logic without the overhead of handling API endpoints.
3. Cleaner Code: Server-side logic is placed within the same file, which keeps your codebase organized and eliminates unnecessary boilerplate.
4. Improved Performance: Since Server Actions execute on the server side, they reduce the need for client-server round trips, improving app performance.

8. Error Handling in Server Actions

Just like any server-side operation, error handling is crucial for Server Actions. You can handle errors by using try-catch blocks inside your Server Actions and returning appropriate responses.

Example of Error Handling:

tsxCopyEdit"use server";

async function saveFormData(data: { name: string; email: string }) {
  try {
    const res = await fetch("https://api.example.com/form", {
      method: "POST",
      body: JSON.stringify(data),
      headers: {
        "Content-Type": "application/json",
      },
    });
    if (!res.ok) throw new Error("Failed to submit data");
    return res.json();
  } catch (error) {
    console.error("Error saving data:", error);
    throw new Error("Form submission failed.");
  }
}

In this example, we catch errors in the Server Action and throw a custom error message.

9. Best Practices for Server Actions

Here are some best practices for using Server Actions in Next.js:

• Modularize Actions: Keep your Server Actions modular and reusable, especially if the same logic is needed in multiple components.
• Handle Errors Properly: Ensure that your Server Actions gracefully handle errors and provide meaningful feedback to the client.
• Secure Sensitive Data: If your Server Action involves sensitive data (e.g., authentication tokens or user information), ensure proper security measures are in place.
• Validate Input Data: Always validate data on the server before performing mutations to avoid unexpected errors.

10. Conclusion

Server Actions in Next.js simplify handling mutations and server-side logic by eliminating the need for separate API routes. They streamline the development process, improve performance, and provide a cleaner and more maintainable codebase.

With the ability to define mutations directly inside your components, Server Actions provide a powerful way to handle data manipulation in a seamless and efficient manner. As you build more complex applications with Next.js, utilizing Server Actions will help you reduce boilerplate code and enhance both the developer and user experience.