Nutmeg Pumpkin Macchiato


    1.3.0 • Public • Published


    Rest-lib is a light-weight framework for building ReSTful APIs


    $ npm install rest-lib

    Quick start

    const ioc = require('nan-ioc');
    const restlib = require('rest-lib');
    class Application {
      onInitialized() {
          .then(() => console.log("Server running"));
    class HelloController {
      list() {
        return "Hello world";
      .controller('helloController', {
        'class': HelloController,
        'context': '/hello'
      .component('application', {
        class: Application,
        expressServer: ioc.ref('expressServer')
        logger: {
          level: 'INFO'

    Start the app:

      node .

    Make a request:

      curl localhost:3000/hello


    To start off you will need to define an Application.js and an index.js

    var Q = require('q');
    module.exports = App;
    App.prototype.onInitialized = function(){
      var bootstrap = [this.syncDb];
      bootstrap.reduce(Q.when, Q(true));
    App.prototype.syncDb = function(){
      return this.dataSource.sync();

    Defining modules

    A module is a group of components with related behavior. You can define a module adding an index file to it like:

    var ioc = require('nan-ioc');
    var Service = require('Service');
    var Controller = require('Controller');
    var DBModel = require('DBModel');
        class: Service
        context: '/hello',
        class: Controller,
        service: ioc.ref('service')
        class: DBModel

    Note: You can have several of each (as long as they have a different definition name), you can reuse your components

    A module can have:


    The methods that you can define on a controller to route through XHR requests are:

    • List: Method GET
    • Get: Method GET with an ID "/context/:id"

    Note: you don't need to define the id, rest-lib will read it automaticly, you can access it from the request object that your method receives

    • Delete: Method DELETE
    • Create: Method POST
    • Update: Method PUT
    module.exports = HelloController;
    var i = 0;
    function HelloController() {
    HelloController.prototype.list = function (command) {
      return {
        'message': this.message + ' ' +
    HelloController.prototype.create = function (command) {
      return this.helloService.create(command);

    For example, for the user context you can have:

    • GET /user -> Lists users
    • GET /user/:id -> Get a user
    • DELETE /user/:id -> Delete a user
    • CREATE /user -> Create a user
    • UPDATE /user/:id -> Update a user

    Sometimes, you need add a nested routes. For example, with posts and comments you need a endpoint that returns all the comments of one post. So, you may define adding in the index file of your module:

        context: '/post',
        routes: {
        posts: {
            verb: 'get',
            route: ':postId/comment'
        class: PostController

    The code above will generate 'GET /post/:postId/comment' and you need to define a comments method in your post controller.

    Also, you can need define a set of methods for the nested routes. For example, following the post and comment context:

    • GET /post/:postId/comment -> Lists the comments for one post
    • GET /post/:postId/comment/:id -> Get a comment for one post
    • DELETE /post/:postId/comment/:id -> Delete a comment for one post
    • CREATE /post/:postId/comment -> Create a comment for a post
    • UPDATE /post/:postId/comment/:id -> Update a comment for one post

    So, you can use the index file of the comment module and put the following code:

        context: '/post/:postId/comment',
        class: CommentController


    There are four differents ways of define params in the validators:

    • Query: Params passed by the Url(/post?MY_PARAM=1)
    • Params: Params that are part of the Url. Most commonly between entities(post/:postId/comment/:id)
    • Body: This params are for the POST or PUT methods.
    • Header: For example, validate the content-type of the request.

    When you define the validator you can specify what type of params you must receive in the controller:

    var Joi = require('joi');
    module.exports = {
      'update': {
        params: {
          id: Joi.number().required()
        body: {
          name: Joi.string().required()
      'list': {
        query: {
          name: Joi.string().required()
      'create': {
        body: {
          name: Joi.string().required()

    Note: If you define a validator for a controller, the methods validated will receive a Command object before the Request and Response objects, in this example the list method would receive an object like:

       name: 'Jon'


    var transactional = require('../').transactional;
    module.exports = HelloService;
    function HelloService(){
    HelloService.prototype.create = transactional({inherit: true, isolationLevel: 'READ COMMITTED'}, function(project){
      return this.model.create(project)


    var jwt = require('jsonwebtoken');
    module.exports = class SessionMiddleware{
        return function(request, response, next){
          var user = request.get('user');

    Database models

    var Sequelize = require('sequelize');
    module.exports = {
      modelName: 'Project',
      attributes: {
        name: {
          type: Sequelize.STRING
      afterDefined: function(models){
        this.belongsToMany(models.User, {through: 'users_project'});


    By default, rest-lib includes a set of mixins for your middlewares, services and controllers. For example, all controller methods throw a not implemented (501) error instead of a 404.


    You can set up a json file for your settings and add them to the index build, as seen in the example index.js file.

    If an authentication field is found, rest-lib will add the express-jwt middleware to verify the requests. If you want your route to not be protected you need to add it in an array in the unsecuredUris field, like:

    authentication: {
      unsecuredUris: ['/auth']

    Note: You will still need to sign your own tokens


    You can set up a connection using Sequelize as seen in the example,

    var ioc = require('nan-ioc');
    var UserModel = require('./User');
    var ProjectModel = require('./Project');
    var App = require('./App');
      .model('User', {
        'class': UserModel
      .model('Project', {
        'class': ProjectModel
        'class': App,
        'env': '${env}',
        'dataSource': ioc.ref('dataSource'),
        'Project': ioc.ref('Project'),
        'User': ioc.ref('User')
        env: 'dev',
          port: 9000
          database: 'restlib',
          username: 'restlib',
          password: 'restlib',
          sync: {force: true},//see
          options: {
            host: 'localhost',
            port: '3306',
            logging: console.log

    Note: You need to inject dataSource into your Application, you can also do this directly on the Application definition (main index.js file)


    npm i rest-lib

    DownloadsWeekly Downloads






    Unpacked Size

    92.2 kB

    Total Files


    Last publish


    • nanlabs