donode

Superfast & Lightweight node framework for building RESTful APIs.

Simple . Flexible . High Performance . ES2015+

Enables developers to focus on writing reusable application logic in a highly modular approach.

Use donode-cli, to get started.

**NOTE: Requires node 8.0 or higher **

High Performance

Here are the performance results.

Documentation

App Structure

Create the app using donode-cli, it is as simple and modular as

• app
  • controllers
  • middleware
  • headers.js
  • routes.js
• env
  • development.env.js
  • production.env.js
• app.js

Routing

One Place for all your routes and they go into app/routes.js.

A Route can be as simple as

{
  path: '/hello',
  method: 'GET',
  handler: 'HelloController@get'
}

| Property | Type | Description | | :--- | :--- | :--- | | path | string | url for the route | | method | string | can be one of GET, POST, PUT, UPDATE, DELETE. | | handler | string | format: SomeController@method Here in this format SomeController is the controller (a class) located in app/controllers directory. And method (name after @) is the name of the method in the given controller, which gets called and send response. more details availale in controllers section. |

Advanced Routing

A Route can take options like middleware, headers, children.

{
  path: '/user/{id}',
  method: 'GET',
  handler: 'UserController@get',
  middleware: ['Auth'],
  headers: ['allow-cors'],
  children: [{
  	path: '/settings',
    method: 'GET',
    handler: 'UserController@settings',
  }]
}

| Property | Type | Description | | :--- | :--- | :--- | | path | string | A route can have params in its path. syntax: {param} example: /user/{id} can respond to /user/1, /user/123 etc..| | method | string | values are not limited GET, POST, PUT, UPDATE, DELETE. can be any type of request that server can listen to. (HEAD, OPTIONS etc..) | | handler | string | A controller can be from a sub directory inside controllers directory. syntax: subdirectory/SomeController@method here in this SomeController is located in app/controllers/subdirectory. | | middleware | array or object | A Middleware is an intermediate handler which can be used to perform some pre-checks such as Auth. It is a class located in app/middleware directory and will be called before the handler method. Array Syntax: ['Middleware1', 'Middleware2'] A list of strings which are the names of the classes from app/middleware directory. When attached to a route, these will be called in the given order before the actual handler. more details availale in middleware section. Object syntax: {    all: ['Middleware1'],    only: ['Middleware2'],    children: ['Middleware3'] } -- all: attached to current the route and all its children. -- only: attached only to current route. -- children: attached to all the children, but not to current route. Note: All are optional. Any of them can be given/ignored. Order: middleware defined under all, children which are coming from parent routes (if any), then all, only of current route. | | headers | array | headers property allows to attach a set of headers that can to be sent along with the response for every request. It takes an array of stings which are defined in app/headers.js. syntax ['allow-cors', 'json-content'] Note: currently headers attached to a route will apply only to it. Not to children. Object syntax is yet to come !!!| | children | array | Routes can be nested with this attribute. This takes list of sub-routes which takes same set of above properties. example route config {   path: '/user/{id}',   method: 'GET',  handler: 'UserController@get',  children: [{     path: '/settings',      method: 'POST',      handler: 'UserController@settings'  }] } this will register the routes GET: /user/{id} POST: /user/{id}/settings |

Controllers

app/controllers: A place for all controllers of the app.

A controller is a class which inherits Controller from donode, and has the handler methods of a route.

const Controller = require('donode').Controller;

class HomeController extends Controller {
  constructor() {
    super();
  }

  get(request, response) {
    response.send({
      'app': 'works !!!'
    });
  }
}

module.exports = HomeController;

The method get(request, response) will be the handler for a route.

handler: 'HomeController@get'

It gets request, response as params.

Request

It is a native Node Request object. Along with default properties it also contains

| Property | Route | Values | | :--- | :--- | :--- | | query | /user?p1=123&p2=donode | { p1: 123, p2: 'donode' } | | params | /user/{id} | { id: 123 } | | body | - | payload sent along with request | | headers | - | headers sent along with request | | url | - | { } | | originalUrl | /user/{id} | /user/123 | | method | - | GET, POST, PUT, DELETE etc.. |

Response

It is a native Node Response object. Along with default properties it also contains

| Method | definition | Description | | :--- | :--- | :--- | | send | send([response_code,] responseObject) | It takes optional response code and a response object which whill be sent. default: 200 (OK) | | reject | reject([response_code], responseObject) | takes optional response_code and rejection responseObject. default: 401 (bad request) | | setHeader | setHeader(type, value) | takes header type and value |

Middleware

const Middleware = require('donode').Middleware;

class Auth extends Middleware {
  constructor() {
    super();
  }

  handle(request, response, next) {
    // do some auth validation here

    // if (not authorized)
    // return response.send(401, { some: 'error data' });

    // else (proceed to the controller hander)
    return next();
  }
}

module.exports = Auth;

Note:

When response.send() or response.reject() are called in a middleware, the call chain stops and handler method will not be called.

Environments

Environments for the app can be managed by creating corresponding configuration file

env/.env.js

This configuration can be used with NODE_ENV while running the app.

$ NODE_ENV= node app.js

Examples:

NODE_ENV=production node app.js
NODE_ENV=stage node app.js

Without NODE_ENV it defaults to development.env.js.