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 **
Here are the performance results.
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
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. |
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 |
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.
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.. |
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 |
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 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.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent