Top Node.js REST API frameworks

November 26, 2015 - Node.js

REST API frameworks for Node.js

Being a software architectural style, REST provides the ability to increase the performance of your projects by introducing more maintainable architecture. If you are using a heavy MVC framework, but need to cope with a fast Node.js REST API server, then pay attention to Node.js REST API frameworks. The best solutions are described in the following post, and they offer the following advantages:

top-notch performance
high scalability
simple interface
customizable components
visibility of processes
portability and reliability

If all these features make sense to you, here is a list of the most popular Node.js REST API frameworks. Please note that all frameworks are arranged in alphabetical order.

Node.js REST API frameworks

actionHero.js
facet
Fortune.js
Frisby
Gugamarket
LoopBack
Raddish
Restberry
restify
restling
restmvc

actionHero.js

actionHero Node.js REST API framework

The first tool in our Node.js REST API frameworks list is actionhero.js.Being a multi-transport API Server, it offers such important features as delayed tasks and integrated cluster capabilities. It means that you can perform various actions that always respond to existing client requests. Moreover, these actions not only respond for the web, but they work for all sorts of clients as well.

Besides, the actionHero Node.js REST API frameworks provides the ability to run tasks in the background, and you can invoke all your tasks from anywhere! Last but not least, is a skill to make clients talk to each other.

Performing actions which respond to client requests with actionhero.js

// actionhero generateAction --name=randomNumber
// File: actions/randomNumber.js

exports.randomNumber = {
  name: 'randomNumber',
  description: 'I am an API method which will generate a random number',
  outputExample: {
    randomNumber: 0.123
  },

  run: function(api, data, next){
    data.response.randomNumber = Math.random();
    next();
  }

};

// actionhero generateAction --name=randomNumber

// File: actions/randomNumber.js

exports.randomNumber = {

description: 'I am an API method which will generate a random number',

outputExample: {

randomNumber: 0.123

run: function(api, data, next){

data.response.randomNumber = Math.random();

next();

}

};

facet

facet Node.js REST API framework

There is also a framework agnostic JSON API platform dubbed Facet among our REST API frameworks for Node.js. The platform makes your JSON API development rapid by providing extensible common utility classes. Besides, it offers the abstraction of middleware specific code, consequently you can rely on framework agnostic use with this tool.

Another important Facet’s feature is the handling of request/response lifecycle. As for CRUD functionality, it is available for all your resources via such functions as findOne, find, create, delete, or update. And don’t forget about event bus management utilized in decoupled communication among modules. For further information, visit the official website of the Node.js JSON API platform.

A new resource API class with Facet

var ApiCore = require('facet-core').ApiCore;

var TodosAPI = function(facet.moduleOptions) {
  // define mongoose schema and bind events here
  // see other facet modules for examples:
  //   https://github.com/facet/gatekeeper
  //   https://github.com/facet/category
  //   https://github.com/facet/catalog
};

/**
 * Todos API inherits from API Core which enables CRUD functionality.
 * The definition of new facet classes would be done in a different 
 * module which depends on facet-core
 */
util.inherits(TodosAPI, ApiCore);

var ApiCore = require('facet-core').ApiCore;

var TodosAPI = function(facet.moduleOptions) {

// define mongoose schema and bind events here

// see other facet modules for examples:

// https://github.com/facet/gatekeeper

// https://github.com/facet/category

// https://github.com/facet/catalog

};

/**

* Todos API inherits from API Core which enables CRUD functionality.

* The definition of new facet classes would be done in a different

* module which depends on facet-core

util.inherits(TodosAPI, ApiCore);

Fortune.js

Fortune Node.js REST API framework

Fortune.js is a Node.js REST API framework that provides data serialization middleware. It covers all aspects of data serialization from storage up to the presentation.

Fortune.js works with the whole application system including the following layers:

adapter – data access layer;
transform – business logic layer;
serializer – presentation layer.

While working together, these layers provide multiple data sources with the ability to be exposed via multiple formats with the help of a uniform interface.

An API with Twitter’s basic functionality via Fortune

// store.js
const fortune = require('fortune')

module.exports = fortune()

.defineType('user', {
  name: { type: String },

  // Following and followers are inversely related (many-to-many).
  following: { link: 'user', inverse: 'followers', isArray: true },
  followers: { link: 'user', inverse: 'following', isArray: true },

  // Many-to-one relationship of user posts to post author.
  posts: { link: 'post', inverse: 'author', isArray: true }
})

.defineType('post', {
  message: { type: String },

  // One-to-many relationship of post author to user posts.
  author: { link: 'user', inverse: 'posts' }
})

// store.js

const fortune = require('fortune')

module.exports = fortune()

.defineType('user', {

// Following and followers are inversely related (many-to-many).

following: { link: 'user', inverse: 'followers', isArray: true },

followers: { link: 'user', inverse: 'following', isArray: true },

// Many-to-one relationship of user posts to post author.

posts: { link: 'post', inverse: 'author', isArray: true }

})

.defineType('post', {

message: { type: String },

// One-to-many relationship of post author to user posts.

author: { link: 'user', inverse: 'posts' }

})

Frisby

Frisby Node.js REST API framework

If you are looking for a Node.js REST API framework for testing, pay attention to Frisby, since it provide vide opportunities for both writing and running tests. Being built on both Jasmine and Node.js, it makes testing API endpoints a piece of cake.

Due to many built-in test helpers, Frisby can easily test expected JSON keys/values, JSON value types, HTTP status codes, etc. With the aid of the Jasmine-Node test runner, the framework is able to run spec tests.

Writing tests with Frisby

var frisby = require('frisby');
frisby.create('Get Brightbit Twitter feed')
  .get('https://api.twitter.com/1/statuses/user_timeline.json?screen_name=brightbit')
  .expectStatus(200)
  .expectHeaderContains('content-type', 'application/json')
  .expectJSON('0', {
    place: function(val) { expect(val).toMatchOrBeNull("Oklahoma City, OK"); }, // Custom matcher callback
    user: {
      verified: false,
      location: "Oklahoma City, OK",
      url: "http://brightb.it"
    }
  })
  .expectJSONTypes('0', {
    id_str: String,
    retweeted: Boolean,
    in_reply_to_screen_name: function(val) { expect(val).toBeTypeOrNull(String); }, // Custom matcher callback
    user: {
      verified: Boolean,
      location: String,
      url: String
    }
  })
.toss();

var frisby = require('frisby');

frisby.create('Get Brightbit Twitter feed')

.get('https://api.twitter.com/1/statuses/user_timeline.json?screen_name=brightbit')

.expectStatus(200)

.expectHeaderContains('content-type', 'application/json')

.expectJSON('0', {

place: function(val) { expect(val).toMatchOrBeNull("Oklahoma City, OK"); }, // Custom matcher callback

user: {

verified: false,

location: "Oklahoma City, OK",

url: "http://brightb.it"

}

})

.expectJSONTypes('0', {

id_str: String,

retweeted: Boolean,

in_reply_to_screen_name: function(val) { expect(val).toBeTypeOrNull(String); }, // Custom matcher callback

user: {

verified: Boolean,

location: String,

url: String

}

})

.toss();

Gugamarket

Gugamarket Node.js REST API framework

Gugamarket is a full stack REST API framework for Node.js that will streamline your coding routine. Besides Node, it also incorporates such technologies as Swagger, Express, Mongoose, Jade, Passwordless, and Mocha. And you can easily install Gugamarket via npm.

LoopBack

LoopBack Node.js REST API framework

The purpose of every good Node.js REST API framework is to let developers focus on user experience and business logic by simplifying the way they design, generate, and test code for their projects. And LoopBack provides this opportunity. With the framework, you will be able to compose scalable APIs rapidly, spending more time on other important aspects.

LoopBack is based on the Express framework and absolutely conforms to the specification of Swagger 2.0. Besides, it is an open source and extensible enterprise-ready software solution with easy data integration and solid API security.

LoopBack modules

LoopBack

Raddish

Raddish Node.js REST API framework

There is also a universal solution among our REST API frameworks for Node.js called Raddish. It incorporate both the power of DCI and MVC in a single software solution. At the same time, the framework is completely decoupled. The major goal of Raddish is to provide developers with the ability to write less code while reaching the same goals. In order to achieve it, the framework utilizes a fallback system. As a result, it is necessary to write a new code only when there is a need to override certain functions.

Restberry

Restberry Node.js REST API framework

As for Restberry, it provides an opportunity to set up your RESTful JSON APIs via Node.js. With the tool, you will be able to define your models with ease or set up CRUD API calls without any need to write code. The Restberry Node.js REST API framework incorporates such API calls that handle and identify issues as well as throw user-friendly HTTP and error responses. Besides, it handles permission and authentication checks. Appropriate errors are thrown as well.

A backend service by Restberry

var restberry = require('restberry');

restberry
    .config({
        apiPath: '/api/v1',
        db: 'mongodb://localhost/weather-app',
        env: 'prod',
        name: 'WEATHER APP',
        port: 5000,
    })
    .listen();

restberry.model('City')
    .schema({
        name: {type: String, required: true},
        location: {
            longitude: {type: Number},
            latitude: {type: Number},
        },
    })
    .routes
        .addCreateRoute()  // POST /api/v1/cities
        .addReadRoute()  // GET /api/v1/cities/:id
        .addReadManyRoute()  // GET /api/v1/cities

var CONDITIONS = [
    'Cloudy',
    'Rainy',
    'Sunny',
];
restberry.model('Weather')
    .schema({
        city: {type: restberry.odm.ObjectId, ref: 'City', required: true},
        date: {type: Date, default: Date.now},
        tempature: {type: Number, required: true},
        condition: {type: String, enum: CONDITIONS, required: true},
    })
    .routes
        .addCreateRoute({  // POST /api/v1/cities/:id/weathers
            parentModel: restberry.model('City'),
        })
        .addReadRoute()  // GET /api/v1/weathers/:id
        .addReadManyRoute({  // GET /api/v1/cities/:id/weathers
            parentModel: restberry.model('City'),
        })

var restberry = require('restberry');

restberry

.config({

apiPath: '/api/v1',

db: 'mongodb://localhost/weather-app',

env: 'prod',

port: 5000,

})

.listen();

restberry.model('City')

.schema({

location: {

longitude: {type: Number},

latitude: {type: Number},

})

.routes

.addCreateRoute() // POST /api/v1/cities

.addReadRoute() // GET /api/v1/cities/:id

.addReadManyRoute() // GET /api/v1/cities

var CONDITIONS = [

'Cloudy',

'Rainy',

'Sunny',

];

restberry.model('Weather')

.schema({

city: {type: restberry.odm.ObjectId, ref: 'City', required: true},

date: {type: Date, default: Date.now},

tempature: {type: Number, required: true},

condition: {type: String, enum: CONDITIONS, required: true},

})

.routes

.addCreateRoute({ // POST /api/v1/cities/:id/weathers

parentModel: restberry.model('City'),

})

.addReadRoute() // GET /api/v1/weathers/:id

.addReadManyRoute({ // GET /api/v1/cities/:id/weathers

parentModel: restberry.model('City'),

})

restify

restify Node.js REST API framework

Restify is a Node.js REST API framework that helps developers build stunning REST web services. Being based on Express, Restify essentially enhances its default capabilities. The framework provides full control over interactions with HTTP. Besides, you will get full observability into both the characteristics and latency of your apps.

Restify server usage

var restify = require('restify');

var server = restify.createServer({
  name: 'myapp',
  version: '1.0.0'
});
server.use(restify.acceptParser(server.acceptable));
server.use(restify.queryParser());
server.use(restify.bodyParser());

server.get('/echo/:name', function (req, res, next) {
  res.send(req.params);
  return next();
});

server.listen(8080, function () {
  console.log('%s listening at %s', server.name, server.url);
});

var restify = require('restify');

var server = restify.createServer({

version: '1.0.0'

});

server.use(restify.acceptParser(server.acceptable));

server.use(restify.queryParser());

server.use(restify.bodyParser());

server.get('/echo/:name', function (req, res, next) {

res.send(req.params);

return next();

});

server.listen(8080, function () {

console.log('%s listening at %s', server.name, server.url);

});

restling

restling Node.js REST API framework

If you are looking for a lightweight module designed to streamline the way you build promise-based asynchronous HTTP requests, we recommend you to check Restling. This REST API framework for Node.js incorporates restler and bluebird. The first one for making HTTP calls, and the second one for transforming them in promises. It is also necessary to mention that the nature of Restling will help you avoid callback hell. In addition to easy interface, you will gate a lot of automated processes, such as serialization of post data or query string data.

Restling callback approach

User.logIn("user", "pass").then(function(user) {
  return query.find();
}).then(function(results) {
  return results[0].save({ key: value });
}).then(function(result) {
  // the object was saved.
});

User.logIn("user", "pass").then(function(user) {

return query.find();

}).then(function(results) {

return results[0].save({ key: value });

}).then(function(result) {

// the object was saved.

});

restmvc

restmvc Node.js REST API framework

RestMVC is designed to help you write RESTful web services via Node.js, Mongoose, MongoDB, and Express. The Node.js REST API framework provides the ability to prevent doing repetitive tasks. It offers tools for building project skeletons and empty models, features auto-generate controllers and routes, as well as handles various errors in a clean and nice way.

Defining a model with RestMVC

exports.person = function (mongoose) {
    var schema = mongoose.Schema;

    mongoose.model('Person', new schema({
        firstName: String,
        lastName: String,
        initial: String,
        dateOfBirth: Date
    }));

    return mongoose.model('Person');
};

exports.person = function (mongoose) {

var schema = mongoose.Schema;

mongoose.model('Person', new schema({

firstName: String,

lastName: String,

initial: String,

dateOfBirth: Date

}));

return mongoose.model('Person');

};

______

Do you think the post lacks some Node.js REST API frameworks? Please let us know through the comment field below.

← Previous Post Next Post →

Node.JS From Essentials To Mastery (Best Books)

Have you ever experienced this intense need for mastering Node.JS but at the same time had no time or possibility… Read more…
Node.js In Production

The appearance of Node.js made a great resonance in the coding community. The solution has simplified a lot of complicated… Read more…
Node.js Full Stack Frameworks Overview

Although some users think that Node.js is a web application framework, it is not correct. Being a platform developed to… Read more…
Node.js (Best CMS, E-Commerce systems, and Open Source projects)

Our Node.js tutorial includes all the important information about this runtime environment. It provides both theory and practical examples. Being an… Read more…
Node.js Security Improvements

In the following post, we are going to discuss crucial Node.js security improvements. The platform itself is not very risky,… Read more…
The Ultimate Node.js Tutorial

If you are willing to learn everything about Node.js, we are willing to provide you with all necessary materials. The… Read more…
Database for Node.js: Drivers, Builders, and Mappers

Below, you will find a list of Node.js plugins and tools designed to connect the platform with various databases divided… Read more…
Top Node.js REST API frameworks

Being a software architectural style, REST provides the ability to increase the performance of your projects by introducing more maintainable… Read more…
Node.js Natural Language Processing Projects

Node.js offers enough resources to run various natural language processing projects taking the area of human-computer interaction to a new… Read more…
17 Node.js Tools To Streamline Your Operations With File System

Utilities described in this article will essentially improve your daily work with a file system. Below, you will find 17… Read more…
75 Best Node.js Command Line Apps & Utilities

Below, you will find a comprehensive list of Node.js command line apps and utilities. We’ve gathered 75 various tools approved… Read more…
Node.js –prof – Profiling Node.JS Applications

This article will help you to find out more information about Node.js --prof, since the following Node.js tutorial sheds light… Read more…
Node.js -g parameter

The following node.js tutorial explains the usage of a -g parameter. The Node.js -g parameter installs Node.js globally. It can… Read more…
Node.js Development Environment From Scratch

There are a lot of all possible tools that simplify the development of Node.js projects. Different IDEs, frameworks, debuggers, CMS,… Read more…
The Best Node.js IDEs

If you are a Node.js developer, then you’ve come to the right place, because below we describe the best Node.js… Read more…
Node.js vs Java

You must have noticed that due to recent discussions over Node.js competitiveness, we have been comparing it to other programming… Read more…
The Best Node.js Application Monitoring Tools

Here, on the Firebear blog, we are exploring such interesting phenomenon as Node.js. In the appropriate category on our website,… Read more…
Node.JS Debugging Tools

In software development, the process of finding and resolving bugs is called debugging. Since various defects prevent whole systems from… Read more…
Node.js vs Ruby on Rails

Is Ruby on Rails dying? Is it going to be replaced with Node.js? We all have heard such talks before as… Read more…
Node.js vs PHP

Today, we are going to talk about world famous platforms such Node.js and PHP. We'll try to find out which… Read more…