Humble-Server
nodejs framework that provide convenient, steady service.
https://github.com/stephenkingsley/humble-server
Example
Installation
humble-server requires node v8 or higher and async function support.
$ npm install humble-server — saveHello Humble
const HumbleServer = require(‘humble-server’);
const humbleServerApp = new HumbleServer({
numCPUs: 1,
port: 6969,
});humbleServerApp.router.get(‘/hello’, () => ‘hello humble’);humbleServerApp.start();
Controller
This is the core for a nodejs app. The developer can design your own logic in this http request.
The rule number one is the controller must be `async/await` function. The return value will send automatically.
async function home(context) {
const ret = await context.render(‘home.html’, { title: ‘Humble-Server’ });
return ret;
}module.exports = home;
Router
Now let look back on [Hello Humble]. Using humbleServerApp.router to register controller router.
Route paths will be translated to regular expressions using path-to-regexp.
Base Apis
humbleServerApp.router[method](path, controller)
— method: `get`, `post`, `put`, `delete`, `patch`.
— path: url path.
— controller: controller
const home = require(‘./controller/home’);
humbleServerApp.router.get(‘/home’, home);humbleServerApp.router.dynamicRouter(method, path)
— method: http method, such as `get`, `post`, `put`, `delete`, `patch`.
— path: url path.
In this api, Humble will find the controller according to your path.
humbleServerApp.router.dynamicRouter(‘get’, ‘/v1/api/:path*’);when http.req.url is /v1/api/user/getUserInfo that is match /v1/api/:path. path-to-regexp will return user/getUserInfo that is the value of /:path*. And then Humble will execute ${your project dir}/controller/user/getUserInfo.js.
Middleware
Humble is a middleware framework such as Koa that use async function.
Here is an example of logger middleware
async function log1(context, next) {
const startTime = new Date().getTime();
console.log(` — — start middleware log1 url: ${context.req.url} — -`);
const res = await next();
console.log(` — — end middleware log1 url: ${context.req.url} dur: ${new Date().getTime() — startTime} — -`);
return res;
}module.exports = log1;
Next
In middleware, `next` function is important that can execute next middleware automatically. So you can design your own logic in middleware.
Plugin
Plugin is another elegance architecture. Create your own plugins in /plugin folder without any config. In the controller you can run context.plugin[${your plugin file name}].
// controller
async function home(context) {
context.plugin.log.info(‘ — — hello — -’);
return ‘hello’;
}module.exports = home;
The rule of plugin is the plugin must be class.
// plugin log
class Log {
info(str) {
console.log(str);
}
}module.exports = Log;
Config
Config will according to your NODE_ENV to require. But you have to has config.default.js file, this is the default config.
Config file name: config.${NODE_ENV}.js
$ NODE_ENV=production node index.jsHumble will loading config/config.default.js and config/config.production.js
Middleware Config
if you have some middleware to run with any http request, you should defined in config.
module.exports = {
middleware: [
‘middleware1’,
‘middleware2’,
],
};View
View use nunjucks. There is a api that name render can using in controller.
// /controller/home.js
async function home(context) {
const ret = await context.render(‘home.html’, { title: ‘Hello Humble-Server’ });
return ret;
}
module.exports = home;and html template such as
<html>
<head>
<title>{{ title }}</title>
</head>
<body>
<h1>hello Humble-Server</h1>
</body>
</html>context.render(template, data)
— template: the html file name, Humble will find this file in view folder.
— data: the data will pass to html template
Develop
This project provided an example, just run `npm run dev`!
