Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/madhusudhand/donode

Super fast & Lightweight node framework to build RESTful APIs.
https://github.com/madhusudhand/donode

es6 framework javascript mvc node-framework node-js nodejs

Last synced: 25 days ago
JSON representation

Super fast & Lightweight node framework to build RESTful APIs.

Awesome Lists containing this project

README 

        
# 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](https://www.npmjs.com/package/donode-cli), to get started.**



**NOTE: Requires node 8.0 or higher **



## High Performance



Here are the [performance results](https://github.com/madhusudhand/node-performance).



## Documentation



### App Structure



Create the app using [donode-cli](https://www.npmjs.com/package/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 available 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 available 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.



```js

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`.