How to Create Node JS REST API? 4 Frameworks to Discover

What is REST?

REST or in other words — REpresentational State Transfer — was first introduced in 2000 by Roy Fielding. It is a software architectural style that was created to guide the design and development of the architecture of the World Wide Web architecture. There are defined constraints in the interaction between REST web services.

But what was used before REST for the integration of APIs? Before the REST era building an API was much more complicated, as technology wasn’t so developed. There were, however, ways to build it with, for example, SOAP (Simple Object Access Protocol) or CORBA (Common Object Request Broker Architecture), though it was much harder than it is today. So thanks Roy Fielding, you’ve done a great job with REST! Now back to the topic.

A REST server is used for providing access to resources and modifying them, and the entire REST architecture and its rules are used for the creation of the REST API. Each resource is identified by a URI and represents it, for example, in text, XML, or the most popular – JSON format. RESTful applications use a specific HTTP request method to communicate. The most popular HTTP methods are referred to as CRUD (Create Read Update Delete).

Let’s take a look at these different methods below:

GET request – used to get read-only access to resources.
POST request – used to create or insert new resources.
PUT request – used to update existing resources.
DELETE request – used to remove existing resources.

The REST architectural style describes six guiding constraints. When applying these to the system architecture, it gains desirable non-functional properties, such as performance, scalability, simplicity, modifiability, visibility, portability, and reliability.

The formal REST architecture constraints are as follows:

Uniform interface – fundamental to the design of any RESTful system. It simplifies and decouples the architecture and makes each part of the system independent. It’s using URIs to identify resources. Each resource is conceptually separated from the representations that are returned to the client. The server defines the type of the transfer model.
Statelessness – no session information is retained by the server, which makes it ideal for high volume applications; at the same time statelessness increases the performance.
Cacheability – can provide stale or inappropriate data in response to further requests to improve performance and scalability.
Client-server – according to the rule of separation, the concerns enforced by that design, separate the user interface from the data storage.
Layered system – client cannot ordinarily tell if it is connected directly to the end server or to the intermediary server. If a proxy server or load balancer is placed between the client and server, it does not disrupt their communication.
Intermediary servers can improve system scalability by enabling load balancing and by providing shared caches.
Code on demand (optional) – server can temporarily extend or customize the functionality of a client by transferring executable code.

REST has been in high demand for many years. It is an integral part of many web applications like mobile applications, single-page applications, and also in microservices. Building a Node.js RESTful API can be performed by using a variety of programming languages, i.e., C# with .NET Core, PHP with Laravel, Python with Django, or JavaScript with Node.js, which will be presented in this article in more detail.

What is Node.js?

Node.js is a JavaScript runtime environment. It is designed to build scalable network applications using JavaScript outside of the browser. Node was created in 2009 and it is used today by giants like GoDaddy, Microsoft, Netflix, and Paypal. Before, JavaScript was mainly used for developing client-side applications that ran in web browsers. With Node.js, JavaScript became a full-stack language.

The most important advantages of Node.js are:

Cross-platform – Node may run on Linux, Windows, Mac, and other operating systems.
Scalability – easy to scale in horizontal and vertical directions. It facilitates load balancing over multiple CPU cores without using RAM as much; moreover, it uses an event-loop mechanism.
Allows to leverage microservices – the app can be separated into many small parts.
Huge community – support from millions of developers, many NPM packages, libraries, and frameworks.
High performance – Node uses the Google V8 JavaScript engine to compile JavaScript to machine code.
Easy to learn – developers work with the well-known JavaScript language; it is especially friendly to frontend web developers who have the possibility to run JS outside the web browser.

Node.js uses event-driven programming, which allows web developers to build fast web servers that use callback functions to signal the completion of a task. Moreover, developers can create highly scalable servers without using threading. The Node event mechanism manages tasks to avoid blocking them and the operating system. The core of Node is Google’s V8 Javascript engine, the same that uses the Chrome browser.

You may wonder, how can you transfer data between a server and a web app? That’s where the JSON file comes in. It’s a lightweight JavaScript Object Notation file that helps transmit the data.

Node.js operates on a single-thread event loop using non-blocking input/output calls. It allows supporting thousands of concurrent connections without incurring the cost of a thread context switch. According to the design, the single thread with an observer pattern is shared between all tasks.

The Node.js community is huge (over 110k+ people using the framework – according to Stackshare), mainly due to the well-known JavaScript language. There are millions of open-source libraries available mostly on NPM (Node Package Manager). Developers have created many web frameworks to accelerate the development of applications. Among the most popular are: Express.js, Sails, Koa.js, Socket.io, Hapi.js.

REST Node API Frameworks

There are many Node.js frameworks and libraries. In this article, we will take into consideration only those which allow us to build a RESTful API. I will choose the most popular ones and explore the differences between them.

Express

Express is the most popular Node framework with over 55k stars on Github. Based on data from NPM, the weekly number of downloads reaches over 18 billion, which makes Express the most popular framework for Node.js. But how to install Express?

Well, installing Express is really easy and is only limited to short command execution. In order to do so, simply run the following command:

npm install –save express

That’s it!

Below, you can find an example of the “Hello World!” Express app:

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

app.get('/', (req, res) => res.send('Hello World!'));

app.listen(port, () => console.log(`App started on ${port}!`))

Express is easy to learn and use, and it stands out with its minimalism and high flexibility, which makes it ideal for building a simple REST API. It wraps a fundamental Node logic with a thin layer that gives possibilities to handle HTTP requests and use middlewares. Additionally, there are many packages with new and additional features created by the huge community that uses Express.

Advantages

Quick development.
Highly supported by the open-source community.
Many third-party applications.

Disadvantages

Developers are responsible for ensuring security.
In complex applications, the code structure is really important and could result in maintenance problems.

Hapi

Over 13.6k stars on Github, over 460k downloads a week, and huge performance success with Walmart. Hapi provides an abstraction layer that helps to split an application into several logic components. The application has a plugin-based structure which has a positive effect on scaling. Hapi’s built-in logic is necessary for creating a complex application, for example, non-trivial routing configuration, authorization, or validation.

To install, you have to run “npm install –save @hapi/hapi”.

Import Hapi from '@hapi/hapi';

const server = Hapi.server({
    host: 'localhost',
    port: 3000
});

server.route({
    method:'GET',
    path:'/',
    handler: (request,h) => {
      return 'Hello world';
    }
});

const start = async () => {
  try {
      await server.start();
  }
  catch (err) {
        console.log(err);
        process.exit(1);
    }

  console.log(`App started at ${server.info.uri}`);
};

start();

Advantages

Easy to configure.
Quick and efficient development with simple routing pseudo-middleware configuration.
Provides many reusable modules like caching, authentication, and input/output validation.

Disadvantages

No official guidelines for structuring the codebase.
Migration to a different Node framework could be challenging.

Koa

This framework, which has over 32k stars on Github and over 1.2 billion downloads on NPM, was designed by the same team as Express (which has been described above). The goal of Koa was to be smaller and more expressive. It reduces the use of callbacks and greatly increases error handling. It’s a pretty simple framework that resembles Express just a little. Let’s take a look at the following code.

import Koa from 'koa';
import Router from '@koa/router';

const app = new Koa();
const router = new Router();const port = 3000;

router.get('/', (ctx) => {
  ctx.body = 'Hello World';
});

app
  .use(router.routes())
  .use(router.allowedMethods());

app.listen(port);

But before building an app, we need to install Koa and @koa/router. To install both of them, we have to run a specific command: “npm install –save koa koa-router”.

Advantages

Lightweight.
Uses ES6 generators to avoid callbacks.
Uses a context object to encapsulate requests and response objects.

Disadvantages

Not compatible with any other Node.js frameworks including express style middleware.

Nest.js

Github users give over 42k stars to this repository, while NPM statistics show over 1 million weekly downloads. Nest is a framework for building efficient, scalable, server-side applications. Creators use TypeScript and combine many programming attitudes: object-oriented, functional, and functional-reactive.

Nest uses Express under the hood. It aims to provide an architecture that allows the effortless creation of highly testable, scalable, loosely coupled, and easily maintainable applications. The architecture is heavily inspired by one of the frontend frameworks – Angular.

Nest has a built-in CLI method to create a new application. To use it, we need to install the CLI first by running the command “npm install -g @nestjs/cli”. Moreover, in the location where we want to create a new application, we have to use the command “nest new {project name}”.

Because of the architecture, even the most trivial application cannot be written in one file, as controllers, modules, and services have to be separated.

Nest is the most complex of all described frameworks. It’s full of decorators and custom logic which causes a higher entry threshold than other frameworks.

Advantages

Uses TypeScript by default.
Modular structure.
Built-in dependency injection container.
No strong coupling between components.
Architecture inspired by Angular – friendly for Angular developers.

Disadvantages

Deployment causes some downtime.
Too complex for many developers.

Performance

One of the most important criteria while selecting a framework is performance. On the website of a different Node.js framework, there are results of benchmark testing the performance of selected frameworks.

All of the frameworks we took into consideration above, were part of this test, with the exception of Nest.js.

Please note that the benchmark test data is constantly updated. On (Date) when this article was published the leader was Koa, right before Hapi, while Express was the last. Since Nest uses Express under the hood, we can actually place Nest next to Express, in the last place.

Truthfully, it’s so hard to compare performance between all the frameworks without complex applications created in all of them. Taking that into account, please remember that the results presented above could be different in apps with more complexity.

Node JS REST API: The Summary

Node.js extends JavaScript’s ability to create complex web applications and makes this language one of the most popular programming languages in the world in recent years.

It’s a relatively new technology and it’s still growing. There are many frameworks you can create a RESTful API with, and new ones are being created all the time. Frameworks, as you can see in this article, have their own pros and cons, and selecting the best one is simply not possible without taking into consideration the scope of your project.

An important thing is developers’ reviews about the frameworks that you need to use in the project. It can give you a broader view of the solution you will be using. The bigger the community, the better the framework you want to use. It means that many people use it and you have more chances to find a solution on the internet when you have a problem with something.

Last but not least, think about the size of your project. If you want to write a simple RESTful API without scaling it up, then it’s probably better to use a simpler framework like Express or maybe write the code in pure JavaScript. On the other hand, if you plan to build a solution that will grow to be large and complex and want to make sure the code will be scalable, Nest will be a better option. The point is to choose wisely and always select a tool adequate to the given problem.

Looking for a reliable Node.js development company? Reach out to us!