How to Build REST APIs with Node.js and Fastify

Have you ever wondered how to create fast and efficient REST APIs? Maybe you're familiar with Node.js, but haven't explored the possibilities of using Fastify, a framework designed for speed and low overhead. In this article, you'll learn how to build REST APIs with Node.js and Fastify that are scalable, performant, and easy to maintain.

But before we dive into the code, imagine this: what if you could build an API in record time that handles thousands of requests per second without compromising performance? Keep reading to unlock the secrets of creating high-performance APIs with Fastify and Node.js.

What Is Fastify?

Fastify is a web framework for Node.js that offers speed and scalability. It was designed to handle high throughput with minimal overhead, making it one of the fastest Node.js frameworks available. Fastify achieves this by focusing on performance optimization, lightweight routing, and extensibility, making it perfect for developers building REST APIs.

Setting Up Your Environment

To start building a REST API with Fastify, follow these simple steps:

Step 1: Install Node.js and npm

First, make sure you have Node.js and npm installed on your machine. If not, you can download them from the official Node.js website.

Once installed, open your terminal and check the version with these commands:

bashCopiar códigonode -v
npm -v

Step 2: Create a New Project Directory

Next, create a folder for your new project. In this example, we'll name the project fastify-rest-api.

bashCopiar códigomkdir fastify-rest-api
cd fastify-rest-api

Step 3: Initialize Your Project

To set up your project, run the following command in your project folder to initialize it as a Node.js application:

bashCopiar códigonpm init -y

This will create a package.json file that will manage your project dependencies.

Step 4: Install Fastify

To use Fastify in your project, you'll need to install it using npm. Simply run:

bashCopiar códigonpm install fastify

Now you're ready to start building your REST API with Fastify.

Creating Your First REST API

Now that our environment is set up, let's get into the fun part: creating a REST API.

Step 1: Build a Simple Server

Let's start by creating a basic Fastify server. Create a file named server.js in the root directory and add the following code:

javascriptCopiar códigoconst fastify = require('fastify')({ logger: true });

fastify.get('/', async (request, reply) => {
  return { hello: 'world' };
});

const start = async () => {
  try {
    await fastify.listen(3000);
    console.log('Server running on http://localhost:3000');
  } catch (err) {
    fastify.log.error(err);
    process.exit(1);
  }
};
start();

This creates a simple Fastify server that listens on port 3000 and responds with a JSON object when you visit the root route.

Run the server using:

bashCopiar códigonode server.js

Open your browser and visit http://localhost:3000. You should see a response: {"hello":"world"}.

Step 2: Creating REST Routes

Let's now extend this server by adding RESTful routes for creating, retrieving, updating, and deleting data.

We'll use a simple users endpoint. Here's how you can add more routes:

javascriptCopiar código// GET all users
fastify.get('/users', async (request, reply) => {
  return { users: [{ id: 1, name: 'John Doe' }] };
});

// POST a new user
fastify.post('/users', async (request, reply) => {
  const newUser = request.body;
  return { user: newUser };
});

This defines two new routes:

• A GET route to fetch users.
• A POST route to add a new user.

Step 3: Handle Data with JSON

In the real world, APIs work with databases. For now, we'll use hardcoded data, but you can replace it with a database later.

Here's an example of handling a POST request with Fastify:

javascriptCopiar códigofastify.post('/users', async (request, reply) => {
  const newUser = request.body;
  // In a real app, you would add this data to a database.
  return { user: newUser };
});

You can use a tool like Postman or cURL to send a POST request to the server:

bashCopiar códigocurl -X POST http://localhost:3000/users -H "Content-Type: application/json" -d '{"name": "Jane Doe"}'

This sends JSON data to your API, which the Fastify server handles.

Adding a Database

Once you're comfortable with creating basic REST routes, the next step is to integrate a database.

Fastify supports various databases like MongoDB, PostgreSQL, and MySQL. Here, we'll show how to use MongoDB.

Step 1: Install MongoDB and Mongoose

To integrate MongoDB with Fastify, you need to install Mongoose, a popular MongoDB ORM for Node.js.

Run the following command:

bashCopiar códigonpm install mongoose

Step 2: Connect to MongoDB

In your server.js file, import Mongoose and set up the connection:

javascriptCopiar códigoconst mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/fastify', { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('MongoDB connected...'))
  .catch(err => console.error(err));

Step 3: Create a Mongoose Model

Define a User model for the data we want to store:

javascriptCopiar códigoconst User = mongoose.model('User', { name: String });

Now, when you POST a new user, you can save it to the database:

javascriptCopiar códigofastify.post('/users', async (request, reply) => {
  const newUser = new User(request.body);
  await newUser.save();
  return { user: newUser };
});

Testing Your API with Postman

Once you've created routes and added your database, it's time to test it with Postman. This tool lets you simulate requests to your API, such as GET, POST, and DELETE. You can also use cURL for testing directly from the command line.

For example, using Postman, send a POST request to http://localhost:3000/users with the following JSON body:

jsonCopiar código{
  "name": "Alice"
}

You should see the new user returned in the response and saved to your MongoDB database.

Conclusion

You've just built a high-performance REST API using Fastify and Node.js, capable of handling various routes, including GET and POST requests. This API is lightweight, easy to extend, and built on top of the Fastify framework, which is gaining traction in the developer community for its speed and simplicity.

Feel free to explore more by adding features like authentication, validation, and more complex data handling. If you’re looking to dive deeper into creating fast, scalable APIs, be sure to check out more guides and tutorials on how to build REST APIs with Node.js and Fastify.

Whether you're building APIs for a simple app or a large-scale enterprise solution, Fastify is the framework you’ll want to explore further. Keep experimenting, building, and expanding your API knowledge!