How to Build Scalable Rest API with Node.js

Nodejs is one of the popular options to build scalable REST APIs for modern web apps. Today’s apps heavily rely on APIs. And Node.js is an excellent option for REST API development that provides an option to build quickly with less effort. This guide provides a step-by-step approach to RESTful API using Node.js and Express.js. Even if you are a beginner, you can build the REST API with the method below.

What Is REST and Why Use Node.js for REST APIs?

Representational State Transfer (REST) is an architectural style for designing networked applications, particularly web APIs. A REST API enables client-server communication through stateless, standardized operations, typically using HTTP methods.

It has statelessness, which means each request is independent and includes all necessary information. Clients and servers are separate, which makes it flexible to make changes to the front end and back end. Lastly, uniform interfaces ensure the resources are accessed in the same manner in the form of the URL and HTTP verbs.

Talking about Node.js, it is a JavaScript runtime built on Chrome’s V8 engine, and is exceptionally well-suited for REST APIs development. It is event-driven, non-blocking, therefore, efficient enough to handle a stream of concurrent requests, thus ideal for high-performance APIs. Since Node.js uses JavaScript across the stack, developers can streamline development by using the same language for both frontend and backend. 

Nodejs is mainly popular as it enables rapid development of REST APIs, with a vibrant ecosystem of packages via npm. In summary, Node.js gives you these benefits for API development.

1. Speed: Node.js’s asynchronous nature ensures fast request processing.
2. Scalability: It supports horizontal scaling through clustering.
3. Community: A vast npm registry offers tools for rapid development.
4. Flexibility: JavaScript’s versatility simplifies full-stack development.

These features make Node.js a top choice for crafting rest in node js applications, particularly when paired with frameworks like Express.js.

Key HTTP Methods for RESTful API with Express

Express is one of the most popular Node frameworks that reduces the complexity in API development, speeding up the development process. It is one of the top choices when it comes to building APIs with Node.js.

Express.js is very lightweight. It greatly simplifies the implementation of the CRUD methods by offering a powerful routing system. RESTful APIs rely on HTTP methods to perform CRUD (Create, Read, Update, Delete) operations. Understanding how each HTTP method maps to CRUD is essential for building an express js rest api.

The GET method retrieves resources from the server, such as fetching a list of users or a specific record. In Express, a GET endpoint is defined using app.get(). For example, to fetch all users, you might write:

app.get('/users', (req, res) => {
  res.status(200).json(users);
});

This endpoint returns a JSON response with a 200 status code, indicating success. Proper response formatting ensures clients can parse data reliably.

POST requests create new resources, such as adding a user to a database. Express handles POST requests via app.post(), parsing the request body with middleware like body-parser. A POST endpoint might look like:

app.post('/users', (req, res) => {
  const user = req.body;
  users.push(user);
  res.status(201).json(user);
});

Validation ensures the request body contains required fields, enhancing the reliability of rest api in express js.

PUT and PATCH methods update existing resources. PUT replaces an entire resource, while PATCH applies partial updates. For example, a PUT endpoint to update a user might be:

app.put('/users/:id', (req, res) => {
  const { id } = req.params;
  const updatedUser = req.body;
  users[id] = updatedUser;
  res.status(200).json(updatedUser);
});

A PATCH endpoint, conversely, updates specific fields, preserving others. Both methods require careful validation to prevent unintended data overwrites.

DELETE removes resources, such as deleting a user by ID. An Express DELETE endpoint could be:

app.delete('/users/:id', (req, res) => {
  const { id } = req.params;
  users.splice(id, 1);
  res.status(204).send();
});

A 204 status code indicates successful deletion without returning content. Proper status code handling is critical for a restful api with express.

Steps to Set Up a Node.js API Project

Creating a Node.js API begins with setting up the development environment.

You need to first install Node.js and npm, its package manager.

These can be downloaded on Windows or macOS from nodejs.org.

Once installed, you can verify if Nodejs is running on your system or not.

For this, go to terminal and run commands node -v and npm -v

Linux users can use package managers: 

1. apt (Advanced Package Tool): used in Debian-based systems like Ubuntu.
2. yum (Yellowdog Updater, Modified): used in Red Hat-based systems like CentOS or Fedora.

Upon verifying, initialize a project.

Now you have to set up Nodejs. To set up Node.js:

1. Create a directory: This is just making a folder where your project will live.
2. Run npm init -y: This command creates a package.json file with default values, skipping all the setup questions. The -y flag stands for “yes to all.”

So in plain terms: you're telling Node.js, “Here’s my project folder, go ahead and set it up with the basics.

This generates a package.json file, which tracks dependencies and scripts. The package.json is the heart of your project. It defines metadata and enables reproducible builds.

Install essential dependencies, including Express.js for routing and body-parser for parsing JSON requests.

Run:

npm install express body-parser

Express simplifies API development, while body-parser handles incoming data. Additional packages like cors for cross-origin requests may be needed for production. Each dependency serves a specific role in how to create api node.js from scratch.

Organize your project with a clear folder structure:

1. /routes: Contains route definitions.
2. /controllers: Handles business logic.
3. /models: Defines data schemas.
4. /middleware: Stores reusable middleware.

A typical structure might be:

my-api/

├── node_modules/

├── package.json

├── index.js

├── routes/

│   └── users.js

├── controllers/

│   └── usersController.js

└── middleware/

    └── auth.js

This structure promotes maintainability and scalability. These two are always essential for scalable node js api creation.

See also:  Best Node.js Open Source Projects in GitHub

Build APIs with Node.js and Express

With the project set up, you will now have to create the core Express application.

For this, initialize the server in Index.js

const express = require('express');
const app = express();
const port = 3000;

app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

This code starts a server on port 3000, forming the foundation of building apis with node js.

Middleware enhances Express functionality. Use express.json() to parse JSON requests and cors for cross-origin support:

app.use(express.json());
app.use(require('cors')());

const express = require('express');
const router = express.Router();
const usersController = require('../controllers/usersController');

router.get('/', usersController.getAllUsers);
router.post('/', usersController.createUser);

module.exports = router;

In controllers/usersController.js, implement logic:
exports.getAllUsers = (req, res) => {
  res.status(200).json([]);
};
exports.createUser = (req, res) => {
  res.status(201).json(req.body);
};

Import routes in index.js:
app.use('/users', require('./routes/users'));

const { validateUser } = require('../middleware/validate');
exports.createUser = (req, res) => {
  const { error } = validateUser(req.body);
  if (error) return res.status(400).json({ error: error.details[0].message });
  res.status(201).json(req.body);
};

exports.getAllUsers = (req, res) => {
  res.status(200).json(users);
};
exports.getUserById = (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (!user) return res.status(404).json({ error: 'User not found' });
  res.status(200).json(user);
};

exports.updateUser = (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (!user) return res.status(404).json({ error: 'User not found' });
  Object.assign(user, req.body);
  res.status(200).json(user);
};

DELETE removes resources:
exports.deleteUser = (req, res) => {
  const index = users.findIndex(u => u.id === parseInt(req.params.id));
  if (index === -1) return res.status(404).json({ error: 'User not found' });
  users.splice(index, 1);
  res.status(204).send();
};

const jwt = require('jsonwebtoken');
exports.auth = (req, res, next) => {
  const token = req.header('Authorization')?.replace('Bearer ', '');
  if (!token) return res.status(401).json({ error: 'No token provided' });
  try {
    const decoded = jwt.verify(token, 'secret');
    req.user = decoded;
    next();
  } catch (err) {
    res.status(401).json({ error: 'Invalid token' });
  }
};

const { body, validationResult } = require('express-validator');
exports.validateUser = [
  body('name').notEmpty().withMessage('Name is required'),
  (req, res, next) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) return res.status(400).json({ errors: errors.array() });
    next();
  }
];

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Something went wrong!' });
});

const cluster = require('node:cluster');
const numCPUs = require('os').const numCPUs = process.env.WEB_CONCURRENCY || os.cpus().length;
if (numCPUs.length) cluster.isPrimary) {
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  app.listen(port);
}