Unlocking the Power of Next.js Server Actions for Endpoints that Aren’t Invoked from the Client Side

Are you tired of dealing with cumbersome server-side logic in your Next.js application? Do you want to learn how to harness the full potential of server actions for endpoints that aren’t invoked from the client side? Look no further! In this comprehensive guide, we’ll delve into the world of Next.js server actions and explore the possibilities of leveraging them for server-side logic that doesn’t depend on client-side requests.

What are Next.js Server Actions?

Before we dive into the meat of the article, let’s quickly cover the basics. Server actions in Next.js are functions that run on the server-side and can be invoked from the client-side using API routes or from other server-side logic. These actions can perform complex operations, interact with databases, and even return data to the client-side. But what happens when you want to use server actions for endpoints that aren’t invoked from the client side?

The Problem: Server Actions for Endpoints Not Invoked from the Client Side

By default, Next.js server actions are designed to be invoked from the client side using API routes. However, there are scenarios where you might need to use server actions for endpoints that don’t receive requests from the client side. For instance:

• Cron jobs that run periodically to update data or perform maintenance tasks
• Webhooks that receive notifications from external services
• Server-side tasks that need to be triggered by other server-side logic

In these cases, traditional Next.js server actions won’t work as they rely on client-side requests to trigger the action. So, how do you overcome this limitation?

The Solution: Using `next-api` and `micro` to Create Custom Server Endpoints

The solution lies in using the `next-api` and `micro` packages in conjunction with Next.js to create custom server endpoints that can be triggered by server-side logic.

Step 1: Install the Required Packages

npm install next-api micro

Once you’ve installed the packages, you can start creating your custom server endpoint.

Step 2: Create a Custom Server Endpoint

// pages/api/my-endpoint.js
import { NextApiRequest, NextApiResponse } from 'next-api';
import { createMicro } from 'micro';
import { MyServerAction } from './my-server-action';

const micro = createMicro();

const MyEndpoint = async (req: NextApiRequest, res: NextApiResponse) => {
  try {
    const result = await MyServerAction();
    return res.json(result);
  } catch (error) {
    return res.status(500).json({ error: 'Internal Server Error' });
  }
};

micro(MyEndpoint).listen(3001, () => {
  console.log('Server listening on port 3001');
});

In the above example, we’ve created a custom server endpoint at `http://localhost:3001/api/my-endpoint`. This endpoint is not bound to a client-side request and can be triggered by server-side logic.

Step 3: Implement Your Server Action

// pages/api/my-server-action.js
import { getDatabaseConnection } from './database';

export async function MyServerAction() {
  const db = await getDatabaseConnection();
  const data = await db.query('SELECT * FROM my_table');
  return data;
}

In this example, we’ve created a server action that connects to a database, runs a query, and returns the result. This action can be triggered by the custom server endpoint we created earlier.

Triggering the Server Endpoint from Server-Side Logic

Now that we have our custom server endpoint and server action in place, let’s explore ways to trigger the endpoint from server-side logic.

Method 1: Using `next-api`’s Built-in HTTP Client

// pages/api/trigger-endpoint.js
import { HttpClient } from 'next-api';
import { MY_ENDPOINT_URL } from './constants';

const httpClient = new HttpClient();

export async function TriggerEndpoint() {
  try {
    const response = await httpClient.post(MY_ENDPOINT_URL);
    console.log(response.data);
  } catch (error) {
    console.error(error);
  }
}

In this example, we’re using `next-api`’s built-in HTTP client to make a POST request to our custom server endpoint.

Method 2: Using `micro`’s Internal HTTP Client

// pages/api/trigger-endpoint.js
import { micro } from 'micro';
import { MY_ENDPOINT_URL } from './constants';

export async function TriggerEndpoint() {
  try {
    const response = await micro(MY_ENDPOINT_URL);
    console.log(response.data);
  } catch (error) {
    console.error(error);
  }
}

In this example, we’re using `micro`’s internal HTTP client to make a request to our custom server endpoint.

Conclusion

In this article, we’ve explored the world of Next.js server actions and demonstrated how to create custom server endpoints that can be triggered by server-side logic. By leveraging `next-api` and `micro`, you can unlock the full potential of server actions for endpoints that aren’t invoked from the client side. Whether you need to run cron jobs, process webhooks, or trigger server-side tasks, you now have the tools to create robust and scalable server-side logic.

Scenario	Solution
Cron jobs that run periodically	Use a scheduler like `node-cron` to trigger the custom server endpoint
Webhooks that receive notifications from external services	Use a webhook listener like `express-webhook` to trigger the custom server endpoint
Server-side tasks that need to be triggered by other server-side logic	Use `next-api`’s built-in HTTP client or `micro`’s internal HTTP client to trigger the custom server endpoint

By following the steps outlined in this article, you’ll be able to create custom server endpoints that can be triggered by server-side logic, unlocking a world of possibilities for your Next.js application.

Happy coding!

Here are 5 questions and answers about “Next.js server actions for endpoints which aren’t invoked from the client side”:

Frequently Asked Question

Get answers to your burning questions about Next.js server actions!