Merge pull request #3 from BoolJS/develop

Upgrade to node v8.x

Author: pandres95

.editorconfig

@@ -0,0 +1,5 @@
+[*]
+indent_size = 4
+
+[package.json]
+indent_size = 2

.eslintrc.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports = {
+    extends: [ 'standard' ],
+    env: {
+        es6: true,
+        node: true
+    },
+    rules: {
+        indent: [ 'error', 4 ],
+        semi: [ 'error', 'always' ],
+        'no-multi-spaces': 0
+    }
+};

example

@@ -1,30 +1,30 @@
 'use strict';
 
-var API         = require('booljs.api')
-,   lib         = require('./lib/server')
-,   resolver    = require('./lib/utils/resolve');
+const { ServerLoader } = require('booljs.api');
+const lib = require('./lib/server');
+const resolver = require('./lib/utils/resolve');
 
-module.exports = class Express extends API.ServerLoader{
-    constructor(){
+module.exports = class Express extends ServerLoader {
+    constructor () {
         super('booljs.express', [ resolver('lib/middleware/cors') ]);
     }
 
-    init(_instance){
-        return lib.init(_instance);
+    init (instance) {
+        return lib.init(instance);
     }
-    middleware(_instance, router, middleware){
-        return lib.middleware(_instance, router, middleware);
+    middleware (instance, router, middleware) {
+        return lib.middleware(instance, router, middleware);
     }
-    preroute(_instance, expressApplication){
-        return lib.preroute(_instance, expressApplication);
+    preroute (instance, expressApplication) {
+        return lib.preroute(instance, expressApplication);
     }
-    route(_instance, router, middleware, route){
-        return lib.route(_instance, router, middleware, route);
+    route (instance, router, middleware, route) {
+        return lib.route(instance, router, middleware, route);
     }
-    postroute(_instance, expressApplication, router){
-        return lib.postroute(_instance, expressApplication, router);
+    postroute (instance, expressApplication, router) {
+        return lib.postroute(instance, expressApplication, router);
     }
-    boot(expressApplication){
+    boot (expressApplication) {
         return lib.boot(expressApplication);
     }
 };

index.js

@@ -1,42 +1,43 @@
-"use strict";
+'use strict';
 
-var API = require('booljs.api');
+const { RouteMiddleware } = require('booljs.api');
+const _ = require('underscore');
 
 /** @ignore */
-function headers(res, extraHeaders){
-    res.header('Access-Control-Allow-Origin', '*');
-    res.header(
+function headers (response, extraHeaders) {
+    response.header('Access-Control-Allow-Origin', '*');
+    response.header(
         'Access-Control-Allow-Methods',
         ['GET', 'POST', 'PUT', 'DELETE'].join(', ')
     );
-    res.header(
+    response.header(
         'Access-Control-Allow-Headers',
         (extraHeaders || []).concat([
             'Authorization', 'Accept', 'Content-Type', 'X-Requested-With',
             'Cache-Control'
         ]).join(', ')
     );
-    res.header('Access-Control-Expose-Headers',(extraHeaders || []).join(', '));
+    response.header(
+        'Access-Control-Expose-Headers',
+        (extraHeaders || []).join(', ')
+    );
 }
 
-
-module.exports = class ExpressCORS extends API.RouteMiddleware{
-    constructor(){
-        super('booljs-cors', 'mandatory', {
-            cors: true
-        });
+module.exports = class ExpressCORS extends RouteMiddleware {
+    constructor () {
+        super('booljs-cors', 'mandatory', { cors: true });
     }
 
-    action(_instance, router, route) {
+    action (instance, router, route) {
         var extraHeaders = route.corsExtraHeaders ? (
             _.isArray(route.corsExtraHeaders) && route.corsExtraHeaders
         ) || [ route.corsExtraHeaders ] : [];
         router.options(route.url, function (req, res) {
             headers(res, extraHeaders);
             res.status(200).end();
         });
-        return function (req, res, next) {
-            headers(res, extraHeaders);
+        return function (request, response, next) {
+            headers(response, extraHeaders);
             next();
         };
     }

lib/middleware/cors.js

@@ -1,22 +1,24 @@
 'use strict';
 
-module.exports = function (expressApplication) {
-    var http    = require('http')
-    ,   server  = http.createServer(expressApplication);
+const http = require('http');
 
-    var listen = q.nbind(server.listen, server);
+module.exports = async function (expressApplication) {
+    let server  = http.createServer(expressApplication);
 
-    return listen(
-        expressApplication.get('port'), expressApplication.get('host')
-    ).then(function () {
-        if(process.env.NODE_ENV !== 'test'){
-            console.log(
-                'Express server listening on http://%s:%d',
-                expressApplication.get('host'),
-                expressApplication.get('port')
-            );
+    let host = expressApplication.get('host');
+    let port = expressApplication.get('port');
+
+    await new Promise((resolve, reject) => server.listen(port, host, error => {
+        if (error) {
+            return reject(error);
         }
-        return q.resolve(server);
-    });
 
+        return resolve();
+    }));
+
+    if (process.env.NODE_ENV !== 'test') {
+        console.log(`Express server listening on http://${host}:${port}`);
+    }
+
+    return server;
 };

lib/server/boot.js

@@ -1,56 +1,55 @@
 'use strict';
 
-module.exports = function (_instance) {
-    var Express             = require('express')
-    ,   bodyParser          = require('body-parser')
-    ,   expressApplication  = new Express();
+const _ = require('underscore');
+const Express = require('express');
+const BodyParser = require('body-parser');
+
+module.exports = async function (instance) {
+    let expressApplication = new Express();
 
     // X-Powered-By: bool.js
     expressApplication.use(function (req, res, next) {
         res.header('X-Powered-By', 'booljs');
         next();
     });
 
-    var config = _instance.getComponents().configuration.get('server');
+    var configuration = instance.getComponents().configuration.get('server');
 
     // Sets listening hostname
-    expressApplication.set(
-        'host',
-        process.env.IP  || process.env.HOSTNAME || process.env.HOST  ||
-        ( config && (
-            config.ip       || config.hostname      || config.host
-        )) || '0.0.0.0'
-    );
+    expressApplication.set('host', (
+        process.env.IP || process.env.HOSTNAME || process.env.HOST ||
+        (configuration && (
+            configuration.ip || configuration.hostname || configuration.host
+        )) ||
+        '0.0.0.0'
+    ));
 
     // Sets listening port
-    expressApplication.set(
-        'port',
-        process.env.PORT ||
-        ( config &&
-            config.port
-        ) || 3001
-    );
+    expressApplication.set('port', (
+        process.env.PORT || (configuration && configuration.port) || 3001
+    ));
 
     // Enable body-parser middlewares
-    var bodyParserOptions = (config && config.body) || undefined;
+    var bodyParserOptions = (configuration && configuration.body) || undefined;
 
-    if(bodyParserOptions !== undefined) {
-        expressApplication.use(bodyParser.urlencoded(_.extend({
-            extended: true
-        }, bodyParserOptions)));
-        expressApplication.use(bodyParser.json(bodyParserOptions));
+    if (bodyParserOptions !== undefined) {
+        expressApplication.use(BodyParser.urlencoded(
+            _.extend({ extended: true }, bodyParserOptions))
+        );
+        expressApplication.use(BodyParser.json(bodyParserOptions));
     } else {
-        expressApplication.use(bodyParser.urlencoded({ extended: true }));
-        expressApplication.use(bodyParser.json());
+        expressApplication.use(BodyParser.urlencoded({ extended: true }));
+        expressApplication.use(BodyParser.json());
     }
 
     // Enables Json View
-    if(!_instance.getComponents().views){
-        _instance.insertComponent('views', {});
+    if (!instance.getComponents().views) {
+        instance.insertComponent('views', {});
     }
-    _instance.insertComponent(
-        'Json', require('../views/json'), _instance.getComponents().views
+
+    instance.insertComponent(
+        'Json', require('../views/json'), instance.getComponents().views
     );
 
-    return q.resolve(expressApplication);
+    return expressApplication;
 };

lib/server/init.js

@@ -1,8 +1,6 @@
 'use strict';
 
-module.exports = function (_instance, router, middleware) {
-
+module.exports = async function (_instance, router, middleware) {
     router.use(middleware);
-    return q.resolve(router);
-
+    return router;
 };

lib/server/middleware.js

@@ -1,21 +1,13 @@
 'use strict';
 
-module.exports = function (app, router) {
-
-    var json    = new app.views.Json()
-    ,   Error   = app.Error;
+module.exports = function ({ Error, views: { Json } }, router) {
+    let json = new Json();
 
     // 404 Handler. Acts when a resource call isn't found
-    router.use(function(req, res) {
-        json.error(new Error(
-            404, 'method_not_found',
-            'Method wasn\'t found'
-        ), res);
-    });
+    router.use((request, response) => json.error(
+        new Error(404, 'method_not_found', 'Method wasn\'t found'), response
+    ));
 
     // Error Handler. Processes an error output view.
-    router.use(function(err, req, res, next){
-        json.error(err, res);
-    });
-
+    router.use((error, req, response, next) => json.error(error, response));
 };

lib/server/router/handlers.js

@@ -1,8 +1,6 @@
 'use strict';
 
-module.exports = function (_instance, router, middleware, route) {
-
+module.exports = async function (instance, router, middleware, route) {
     router[route.method](route.url, middleware, route.action);
-    return q.resolve(router);
-
+    return router;
 };