not-node 5.0.22 → 5.1.2

package/src/init/middleware.js

@@ -1,30 +1,27 @@
-const log = require('not-log')(module, 'not-node//init');
-const ADDS = require('./additional');
+const log = require("not-log")(module, "not-node//init");
+const ADDS = require("./additional");
 
-module.exports = class InitMiddleware{
-
-  async run({config, options, master}) {
-    log.info('Setting up middlewares...');
-    await ADDS.run('middleware.pre', {config, options, master});
-    const input = config.get('middleware');
-    if (input) {
-      for (let ware in input) {
-        let warePath = input[ware].path || ware,
-          proc;
-        if (require(warePath).getMiddleware) {
-          proc = require(warePath).getMiddleware(input[ware]);
-        } else if (require(warePath).middleware) {
-          proc = require(warePath).middleware;
-        } else {
-          proc = require(warePath);
-        }
-        if(typeof proc === 'function'){
-          master.getServer().use(proc);
+module.exports = class InitMiddleware {
+    async run({ config, options, master }) {
+        log.info("Setting up middlewares...");
+        await ADDS.run("middleware.pre", { config, options, master });
+        const input = config.get("middleware");
+        if (input) {
+            for (let ware in input) {
+                let warePath = input[ware].path || ware,
+                    proc;
+                if (require(warePath).getMiddleware) {
+                    proc = require(warePath).getMiddleware(input[ware]);
+                } else if (require(warePath).middleware) {
+                    proc = require(warePath).middleware;
+                } else {
+                    proc = require(warePath);
+                }
+                if (typeof proc === "function") {
+                    master.getServer().use(proc);
+                }
+            }
         }
-      }
+        await ADDS.run("middleware.post", { config, options, master });
     }
-    await ADDS.run('middleware.post', {config, options, master});
-  }
-
-
 };

package/src/init/modules.js

@@ -1,5 +1,5 @@
-module.exports = class InitModules{
-  async run({master}) {
-    master.getApp().execInModules('initialize');
-  }
+module.exports = class InitModules {
+    async run({ master }) {
+        master.getApp().execInModules("initialize");
+    }
 };

package/src/init/monitoring.js

@@ -1,11 +1,11 @@
-const Log = require('not-log')(module, 'not-node//init');
+const Log = require("not-log")(module, "not-node//init");
 
 module.exports = class InitMonitoring {
-  async run() {
-    const monitor = require('not-monitor').monitor;
-    monitor.on('afterReportError', (err) => {
-      Log.error('Report error', err.message);
-    });
-    Log.log('Development monitor initialized');
-  }
+    async run() {
+        const monitor = require("not-monitor").monitor;
+        monitor.on("afterReportError", (err) => {
+            Log.error("Report error", err.message);
+        });
+        Log.log("Development monitor initialized");
+    }
 };

package/src/init/rateLimiter.js

@@ -1,51 +1,59 @@
-const emit = require('./additional').run;
-const log = require('not-log')(module, 'RateLimiter');
-const {partCopyObj} = require('../common');
+const emit = require("./additional").run;
+const log = require("not-log")(module, "RateLimiter");
+const { partCopyObj } = require("../common");
 
 const DEFAULT_OPTIONS = {
-  keyPrefix: 'rateLimiterMiddleware',
-  points: 20,
-  duration: 1
+    keyPrefix: "rateLimiterMiddleware",
+    points: 20,
+    duration: 1,
 };
 
-const DEFAULT_CLIENT = 'ioredis';
-
-module.exports = class InitRateLimiter{
-
-  static createMiddleware({rateLimiter}){
-    return (req, res, next) => {
-      rateLimiter.consume(req.ip)
-        .then(() =>  next())
-        .catch(() => {
-          log.error('Too many requests by ' + req.ip);
-          res.status(429).send('Too Many Requests');
+const DEFAULT_CLIENT = "ioredis";
+
+module.exports = class InitRateLimiter {
+    static createMiddleware({ rateLimiter }) {
+        return (req, res, next) => {
+            rateLimiter
+                .consume(req.ip)
+                .then(() => next())
+                .catch(() => {
+                    log.error("Too many requests by " + req.ip);
+                    res.status(429).send("Too Many Requests");
+                });
+        };
+    }
+
+    async run({ config, master }) {
+        await emit("rateLimiter.pre", { config, master });
+        const rateLimiter = InitRateLimiter.createRateLimiter({
+            config,
+            master,
         });
-    };
-  }
-
-  async run({config, master}){
-    await emit('rateLimiter.pre', { config, master});
-    const rateLimiter = InitRateLimiter.createRateLimiter({config, master});
-    const middleware = InitRateLimiter.createMiddleware({rateLimiter});
-    master.getServer().use(middleware);
-    await emit('rateLimiter.post', { config, master});
-  }
-
-
-  static getOptions({config}){
-    const opts = partCopyObj(config.get('modules.rateLimiter', {}), Object.keys(DEFAULT_OPTIONS));
-    return {
-      ...DEFAULT_OPTIONS,
-      ...opts
-    };
-  }
-
-  static createRateLimiter({master, config}){
-    const {RateLimiterRedis} = require('rate-limiter-flexible');
-    const storeClient = config.get('modules.rateLimiter.client', DEFAULT_CLIENT);
-    return new RateLimiterRedis({
-      storeClient:  master.getEnv(`db.${storeClient}`),
-      ...InitRateLimiter.getOptions({master, config})
-    });
-  }
+        const middleware = InitRateLimiter.createMiddleware({ rateLimiter });
+        master.getServer().use(middleware);
+        await emit("rateLimiter.post", { config, master });
+    }
+
+    static getOptions({ config }) {
+        const opts = partCopyObj(
+            config.get("modules.rateLimiter", {}),
+            Object.keys(DEFAULT_OPTIONS)
+        );
+        return {
+            ...DEFAULT_OPTIONS,
+            ...opts,
+        };
+    }
+
+    static createRateLimiter({ master, config }) {
+        const { RateLimiterRedis } = require("rate-limiter-flexible");
+        const storeClient = config.get(
+            "modules.rateLimiter.client",
+            DEFAULT_CLIENT
+        );
+        return new RateLimiterRedis({
+            storeClient: master.getEnv(`db.${storeClient}`),
+            ...InitRateLimiter.getOptions({ master, config }),
+        });
+    }
 };

package/src/init/routes.js

@@ -1,74 +1,72 @@
-'use strict';
+"use strict";
 
-const serveStatic = require('serve-static');
-const log = require('not-log')(module, 'not-node//init');
-const {
-  notError,
-  notValidationError,
-  notRequestError
-} = require('not-error');
+const serveStatic = require("serve-static");
+const log = require("not-log")(module, "not-node//init");
+const { notError, notValidationError, notRequestError } = require("not-error");
 
 module.exports = class InitRoutes {
+    static finalError({ master }) {
+        return (err, req, res, next) => {
+            //reportable errors from known cases
+            if (err instanceof notError) {
+                master.getApp().report(err);
+                //if request params - ok, but result is not
+                if (err instanceof notRequestError) {
+                    if (err.getRedirect()) {
+                        return res.redirect(err.getRedirect());
+                    } else {
+                        return res.status(err.getCode()).json({
+                            status: "error",
+                            message: err.getResult().message,
+                            errors: err.getResult().errors,
+                        });
+                    }
+                    //bad request params
+                } else if (err instanceof notValidationError) {
+                    return res.status(400).json({
+                        status: "error",
+                        message: err.message,
+                        errors: err.getFieldsErrors(),
+                    });
+                }
+            }
+            //other cases
+            if (err instanceof Error && res && res.status && res.json) {
+                res.status(err.statusCode || 500);
+                //reporting as unknown
+                master
+                    .getApp()
+                    .report(
+                        new notError(
+                            `Internal error(${res.statusCode}): %${req.url} - %${err.message}`,
+                            {},
+                            err
+                        )
+                    );
+                res.json({
+                    status: "error",
+                    message: err.message,
+                });
+            } else {
+                log.error("Unknown error:", err);
+                res.status(500).json({
+                    status: "error",
+                });
+            }
+            next();
+        };
+    }
 
-  static finalError({
-    master
-  }) {
-    return (err, req, res, next) => {
-      //reportable errors from known cases
-      if (err instanceof notError) {
-        master.getApp().report(err);
-        //if request params - ok, but result is not
-        if (err instanceof notRequestError) {
-          if (err.getRedirect()) {
-            return res.redirect(err.getRedirect());
-          } else {
-            return res.status(err.getCode()).json({
-              status: 'error',
-              message: err.getResult().message,
-              errors: err.getResult().errors
-            });
-          }
-          //bad request params
-        }else if (err instanceof notValidationError){
-          return res.status(400).json({
-            status: 'error',
-            message:  err.message,
-            errors: err.getFieldsErrors()
-          });
-        }
-      }
-      //other cases
-      if (err instanceof Error && (res && res.status && res.json)) {
-        res.status(err.statusCode || 500);
-        //reporting as unknown
-        master.getApp().report(new notError(`Internal error(${res.statusCode}): %${req.url} - %${err.message}`, {}, err));
-        res.json({
-          status: 'error',
-          message: err.message
-        });
-      } else {
-        log.error('Unknown error:', err);
-        res.status(500).json({
-          status: 'error'
-        });
-      }
-      next();
-    };
-  }
-
-  async run({
-    master,
-    config,
-    options
-  }) {
-    log.info('Setting up routes...');
-    master.getApp().expose(master.getServer());
-    require(options.routesPath)(master.getServer(), master.getApp());
-    master.getServer().use(serveStatic(config.get('staticPath')));
-    master.getServer().use(options.indexRoute);
-    master.getServer().use(InitRoutes.finalError({
-      master
-    }));
-  }
-
+    async run({ master, config, options }) {
+        log.info("Setting up routes...");
+        master.getApp().expose(master.getServer());
+        require(options.routesPath)(master.getServer(), master.getApp());
+        master.getServer().use(serveStatic(config.get("staticPath")));
+        master.getServer().use(options.indexRoute);
+        master.getServer().use(
+            InitRoutes.finalError({
+                master,
+            })
+        );
+    }
 };

package/src/init/security.js

@@ -1,38 +1,42 @@
-const Log = require('not-log')(module, 'not-node//init');
+const Log = require("not-log")(module, "not-node//init");
 
-module.exports = class InitSecurity{
-  getCSPDirectives({config}){
-    try {
-      let corsArr = config.get('cors');
-      let corsLine = (corsArr ? corsArr.join(' ') : '');
-      let CSPDirectives = config.get('CSP');
-      let result = {};
-      Object.keys(CSPDirectives).forEach((nm) => {
-        result[nm + 'Src'] = CSPDirectives[nm].join(' ');
-        if (['default', 'connect'].includes(nm)) {
-          result[nm + 'Src'] += (' ' + corsLine);
+module.exports = class InitSecurity {
+    getCSPDirectives({ config }) {
+        try {
+            let corsArr = config.get("cors");
+            let corsLine = corsArr ? corsArr.join(" ") : "";
+            let CSPDirectives = config.get("CSP");
+            let result = {};
+            Object.keys(CSPDirectives).forEach((nm) => {
+                result[nm + "Src"] = CSPDirectives[nm].join(" ");
+                if (["default", "connect"].includes(nm)) {
+                    result[nm + "Src"] += " " + corsLine;
+                }
+            });
+            return result;
+        } catch (e) {
+            Log.error(e);
+            return {};
         }
-      });
-      return result;
-    } catch (e) {
-      Log.error(e);
-      return {};
     }
-  }
 
-  async run({master, config, options}){
-    //adding protection
-    const helmet = require('helmet');
-    const CSPDirectives = this.getCSPDirectives({options, config, master});
-    master.getServer().use(
-      helmet({
-        contentSecurityPolicy: {
-          directives: {
-            ...CSPDirectives,
-            upgradeInsecureRequests: [],
-          }
-        }
-      })
-    );
-  }
+    async run({ master, config, options }) {
+        //adding protection
+        const helmet = require("helmet");
+        const CSPDirectives = this.getCSPDirectives({
+            options,
+            config,
+            master,
+        });
+        master.getServer().use(
+            helmet({
+                contentSecurityPolicy: {
+                    directives: {
+                        ...CSPDirectives,
+                        upgradeInsecureRequests: [],
+                    },
+                },
+            })
+        );
+    }
 };

package/src/init/sequence.js

@@ -1,121 +1,125 @@
-const Log = require('not-log')(module, 'InitSequence');
-const {objHas} = require('../common');
+const Log = require("not-log")(module, "InitSequence");
+const { objHas } = require("../common");
 
 /**
-* Initialization sequence manipulations
-* Holds list of initalizers and manages em adds/removes
-**/
-module.exports = class InitSequence{
-  constructor(list = []){
-    this.list = [...list];
-  }
-  /**
-  * Insert initalizator after and before specified modules or at the end
-  * @param  {Object}  what    initializator class constructor
-  * @param  {Object}  where   specification where to insert
-  * @param  {Array.String}  where.after   list of constructor names of
-  *                       initalizators after which item should be inserted
-  * @param  {Array.String}  where.before   list of constructor names of
-  *                       initalizators before which item should be inserted
-  **/
-  insert(what, where = {}){
-    if(where && this.list.length > 0){
-      let start = -1, end = this.list.length;
-      if(objHas(where, 'after')){
-        start = this.highestPos(where.after);
-      }
-      if(objHas(where, 'before')){
-        end = this.lowestPos(where.before);
-      }
-      if(start > end){
-        throw new Error('Insertion of initalization module impossible: ' + what.prototype.constructor.name);
-      }
-      if(start > -1){
-        this.list.splice(start + 1, 0, what);
-      }else if(end < this.list.length){
-        this.list.splice(end, 0, what);
-      }else{
-        this.list.push(what);
-      }
-    }else{
-      this.list.push(what);
+ * Initialization sequence manipulations
+ * Holds list of initalizers and manages em adds/removes
+ **/
+module.exports = class InitSequence {
+    constructor(list = []) {
+        this.list = [...list];
     }
-  }
-
-  /**
-  * Removing item and optionally adding few on place of removed
-  * @param {string} rem  name of class of initalizator to remove
-  * @param {Array.Constructor} add  list of class constructors
-  **/
-  remove(rem, add = []){
-    const index = this.pos(rem);
-    if(index > -1){
-      this.list.splice(index, 1, ...add);
+    /**
+     * Insert initalizator after and before specified modules or at the end
+     * @param  {Object}  what    initializator class constructor
+     * @param  {Object}  where   specification where to insert
+     * @param  {Array.String}  where.after   list of constructor names of
+     *                       initalizators after which item should be inserted
+     * @param  {Array.String}  where.before   list of constructor names of
+     *                       initalizators before which item should be inserted
+     **/
+    insert(what, where = {}) {
+        if (where && this.list.length > 0) {
+            let start = -1,
+                end = this.list.length;
+            if (objHas(where, "after")) {
+                start = this.highestPos(where.after);
+            }
+            if (objHas(where, "before")) {
+                end = this.lowestPos(where.before);
+            }
+            if (start > end) {
+                throw new Error(
+                    "Insertion of initalization module impossible: " +
+                        what.prototype.constructor.name
+                );
+            }
+            if (start > -1) {
+                this.list.splice(start + 1, 0, what);
+            } else if (end < this.list.length) {
+                this.list.splice(end, 0, what);
+            } else {
+                this.list.push(what);
+            }
+        } else {
+            this.list.push(what);
+        }
     }
-  }
-
 
-  /**
-  * Replacing existing item or if item is not exists in list
-  * then inserting items accroding to where instruction
-  * @param {string} whatRemove  name of class of initalizator to remove
-  * @param {Array.Constructor} whatInsert  list of class constructors
-  * @param  {Object}  where   specification where to insert
-  * @param  {Array.String}  where.after   list of constructor names of
-  *                       initalizators after which item should be inserted
-  * @param  {Array.String}  where.before   list of constructor names of
-  *                       initalizators before which item should be inserted
-  **/
-  replace(whatRemove, whatInsert = [], where = {}){
-    const pos = this.pos(whatRemove);
-    if(pos > -1){//if what is presented, we replace
-      this.remove(whatRemove, whatInsert);
-    }else{
-      //else, use where to position insertion
-      this.insert(whatInsert, where);
+    /**
+     * Removing item and optionally adding few on place of removed
+     * @param {string} rem  name of class of initalizator to remove
+     * @param {Array.Constructor} add  list of class constructors
+     **/
+    remove(rem, add = []) {
+        const index = this.pos(rem);
+        if (index > -1) {
+            this.list.splice(index, 1, ...add);
+        }
     }
-  }
 
-  pos(what){
-    return this.list.findIndex((val)=>{
-      return val.prototype.constructor.name === what;
-    });
-  }
+    /**
+     * Replacing existing item or if item is not exists in list
+     * then inserting items accroding to where instruction
+     * @param {string} whatRemove  name of class of initalizator to remove
+     * @param {Array.Constructor} whatInsert  list of class constructors
+     * @param  {Object}  where   specification where to insert
+     * @param  {Array.String}  where.after   list of constructor names of
+     *                       initalizators after which item should be inserted
+     * @param  {Array.String}  where.before   list of constructor names of
+     *                       initalizators before which item should be inserted
+     **/
+    replace(whatRemove, whatInsert = [], where = {}) {
+        const pos = this.pos(whatRemove);
+        if (pos > -1) {
+            //if what is presented, we replace
+            this.remove(whatRemove, whatInsert);
+        } else {
+            //else, use where to position insertion
+            this.insert(whatInsert, where);
+        }
+    }
 
+    pos(what) {
+        return this.list.findIndex((val) => {
+            return val.prototype.constructor.name === what;
+        });
+    }
 
-  highestPos(whats){
-    return whats.reduce((prev/*number*/, cur /*string*/)=>{
-      const index = this.pos(cur);
-      if(index > prev){
-        return index;
-      }else{
-        return prev;
-      }
-    }, -1);
-  }
+    highestPos(whats) {
+        return whats.reduce((prev /*number*/, cur /*string*/) => {
+            const index = this.pos(cur);
+            if (index > prev) {
+                return index;
+            } else {
+                return prev;
+            }
+        }, -1);
+    }
 
-  lowestPos(whats){
-    return whats.reduce((prev/*number*/, cur /*string*/)=>{
-      const index = this.pos(cur);
-      if((index > -1) && (index < prev)){
-        return index;
-      }else{
-        return prev;
-      }
-    }, this.list.length);
-  }
+    lowestPos(whats) {
+        return whats.reduce((prev /*number*/, cur /*string*/) => {
+            const index = this.pos(cur);
+            if (index > -1 && index < prev) {
+                return index;
+            } else {
+                return prev;
+            }
+        }, this.list.length);
+    }
 
-  async run(context){
-    for(let Step of this.list){
-      try{
-        if(Step && Step.prototype && Step.prototype.constructor){
-          await ((new Step()).run({...context}));
+    async run(context) {
+        for (let Step of this.list) {
+            try {
+                if (Step && Step.prototype && Step.prototype.constructor) {
+                    await new Step().run({ ...context });
+                }
+            } catch (e) {
+                Log.error(
+                    `Initalization step failed, initializator class name: '${Step.prototype.constructor.name}'`
+                );
+                Log.error(e);
+            }
         }
-      }catch(e){
-        Log.error(`Initalization step failed, initializator class name: '${Step.prototype.constructor.name}'`);
-        Log.error(e);
-      }
     }
-  }
-
 };