not-node 5.0.22 → 5.1.2

package/src/init/app.js

@@ -1,80 +1,87 @@
-const notAppConstructor = require('../app.js');
-const ENV = (process.env.NODE_ENV || 'development');
-const path = require('path');
-const logger = require('not-log');
-const log = logger(module, 'not-node//init');
-const {
-  notErrorReporter
-} = require('not-error');
+const notAppConstructor = require("../app.js");
+const ENV = process.env.NODE_ENV || "development";
+const path = require("path");
+const logger = require("not-log");
+const log = logger(module, "not-node//init");
+const { notErrorReporter } = require("not-error");
 
-const emit = require('./additional').run;
+const emit = require("./additional").run;
 
-module.exports = class InitApp{
-  static AppConstructor = notAppConstructor;
-  static ReporterConstructor = notErrorReporter;
+module.exports = class InitApp {
+    static AppConstructor = notAppConstructor;
+    static ReporterConstructor = notErrorReporter;
 
-  static async createApp({config, options, master}){
-    await emit('app.create.pre', {config, options, master});
-    master.setApp(new InitApp.AppConstructor({mongoose: master.getMongoose()}));
-    await emit('app.create.post', {config, options, master});
-  }
-
-  static async setAppEnvs({config, options, master}){
-    await emit('app.setEnv.pre', {config, options, master});
-    master.setEnv('hostname', config.get('hostname'));
-    master.setEnv('server', `https://` + config.get('host'));
-    master.setEnv('appPath', config.get('appPath'));
-    master.setEnv('name', master.getManifest().name);
-    master.setEnv('fullServerName', config.get('fullServerName'));
-    master.setEnv('dbDumpsPath', config.get('dbDumpsPath'));
-    master.setEnv('rolesPriority', master.getManifest().targets.server.roles);
-    master.getApp().ENV = ENV;
-    await emit('app.setEnv.post', {config, options, master});
-  }
+    static async createApp({ config, options, master }) {
+        await emit("app.create.pre", { config, options, master });
+        master.setApp(
+            new InitApp.AppConstructor({ mongoose: master.getMongoose() })
+        );
+        await emit("app.create.post", { config, options, master });
+    }
 
-  static async initCore({config, options, master}){
-    await emit('app.initCore.pre', {config, options, master});
-    master.getApp().importModuleFrom(path.join(__dirname, '../core'));
-    await emit('app.initCore.post', {config, options, master});
-  }
+    static async setAppEnvs({ config, options, master }) {
+        await emit("app.setEnv.pre", { config, options, master });
+        master.setEnv("hostname", config.get("hostname"));
+        master.setEnv("server", `https://` + config.get("host"));
+        master.setEnv("appPath", config.get("appPath"));
+        master.setEnv("name", master.getManifest().name);
+        master.setEnv("fullServerName", config.get("fullServerName"));
+        master.setEnv("dbDumpsPath", config.get("dbDumpsPath"));
+        master.setEnv(
+            "rolesPriority",
+            master.getManifest().targets.server.roles
+        );
+        master.getApp().ENV = ENV;
+        await emit("app.setEnv.post", { config, options, master });
+    }
 
-  static async importModules({config, options, master}){
-    await emit('app.importModules.pre', {config, options, master});
-    master.getApp().importModulesFrom(config.get('modulesPath'));
-    if (Array.isArray(config.get('importModulesFromNPM'))) {
-      config.get('importModulesFromNPM').forEach((modName) => {
-        master.getApp().importModuleFrom(path.join(config.get('npmPath'), modName), modName);
-      });
+    static async initCore({ config, options, master }) {
+        await emit("app.initCore.pre", { config, options, master });
+        master.getApp().importModuleFrom(path.join(__dirname, "../core"));
+        await emit("app.initCore.post", { config, options, master });
     }
-    await emit('app.importModules.post', {config, options, master});
-  }
 
-  static async createReporter({config,/* options,*/ master}){
-    try {
-      master.getApp().reporter = new InitApp.ReporterConstructor({
-        origin:{
-          server: config.get('host')
-        },
-      });
-      master.getApp().logger = logger(module, 'notApplication');
-    } catch (e) {
-      log.error(e);
+    static async importModules({ config, options, master }) {
+        await emit("app.importModules.pre", { config, options, master });
+        master.getApp().importModulesFrom(config.get("modulesPath"));
+        if (Array.isArray(config.get("importModulesFromNPM"))) {
+            config.get("importModulesFromNPM").forEach((modName) => {
+                master
+                    .getApp()
+                    .importModuleFrom(
+                        path.join(config.get("npmPath"), modName),
+                        modName
+                    );
+            });
+        }
+        await emit("app.importModules.post", { config, options, master });
     }
-  }
 
-  async run({config, options, master}) {
-    try{
-      log.info('Init not-app...');
-      await emit('app.pre', {config, options, master});
-      await InitApp.createApp({config, options, master});
-      await InitApp.setAppEnvs({config, options, master});
-      await InitApp.initCore({config, options, master});
-      await InitApp.importModules({config, options, master});
-      await InitApp.createReporter({config, options, master});
-      await emit('app.post', {config, options, master});
-    }catch(e){
-      master.throwError(e.message, 1);
+    static async createReporter({ config, /* options,*/ master }) {
+        try {
+            master.getApp().reporter = new InitApp.ReporterConstructor({
+                origin: {
+                    server: config.get("host"),
+                },
+            });
+            master.getApp().logger = logger(module, "notApplication");
+        } catch (e) {
+            log.error(e);
+        }
     }
-  }
 
+    async run({ config, options, master }) {
+        try {
+            log.info("Init not-app...");
+            await emit("app.pre", { config, options, master });
+            await InitApp.createApp({ config, options, master });
+            await InitApp.setAppEnvs({ config, options, master });
+            await InitApp.initCore({ config, options, master });
+            await InitApp.importModules({ config, options, master });
+            await InitApp.createReporter({ config, options, master });
+            await emit("app.post", { config, options, master });
+        } catch (e) {
+            master.throwError(e.message, 1);
+        }
+    }
 };

package/src/init/bodyparser.js

@@ -1,15 +1,15 @@
-module.exports = class InitBodyparser{
-  async run({ /*options, config,*/
-    master
-  }) {
-    //HTTP input formating
-    const bodyParser = require('body-parser');
-    master.getServer().use(bodyParser.json({limit: '150mb'}));
-    // for parsing application/json
-    master.getServer().use(bodyParser.urlencoded({
-      limit: '150mb',
-      extended: true
-    }));
-    // for parsing application/x-www-form-urlencode
-  }
+module.exports = class InitBodyparser {
+    async run({ /*options, config,*/ master }) {
+        //HTTP input formating
+        const bodyParser = require("body-parser");
+        master.getServer().use(bodyParser.json({ limit: "150mb" }));
+        // for parsing application/json
+        master.getServer().use(
+            bodyParser.urlencoded({
+                limit: "150mb",
+                extended: true,
+            })
+        );
+        // for parsing application/x-www-form-urlencode
+    }
 };

package/src/init/compression.js

@@ -1,8 +1,7 @@
-
-module.exports = class InitCompression{
-  async run({master/*, config*/}){
-    //compress output
-    const compression = require('compression');
-    master.getServer().use(compression());
-  }
+module.exports = class InitCompression {
+    async run({ master /*, config*/ }) {
+        //compress output
+        const compression = require("compression");
+        master.getServer().use(compression());
+    }
 };

package/src/init/core.js

@@ -1,15 +1,15 @@
-const path = require('path');
-const Fields = require('../fields');
-const notLocale = require('not-locale');
+const path = require("path");
+const Fields = require("../fields");
+const notLocale = require("not-locale");
 
-module.exports = class InitCore{
-  static paths = {
-    fields: path.resolve(__dirname, '../core/fields'),
-    locales: path.resolve(__dirname, '../core/locales'),
-  };
+module.exports = class InitCore {
+    static paths = {
+        fields: path.resolve(__dirname, "../core/fields"),
+        locales: path.resolve(__dirname, "../core/locales"),
+    };
 
-  async run(){
-    Fields.importFromDir(InitCore.paths.fields);
-    await notLocale.fromDir(InitCore.paths.locales, 'core');
-  }
+    async run() {
+        Fields.importFromDir(InitCore.paths.fields);
+        await notLocale.fromDir(InitCore.paths.locales, "core");
+    }
 };

package/src/init/cors.js

@@ -1,27 +1,25 @@
-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 InitCORS{
-
-  static getOriginFilter(whitelist){
-    return (origin, callback) =>  {
-      callback(null, whitelist.includes(origin));
-    };
-  }
-
-  async run({config, options, master}) {
-    await ADDS.run('cors.pre', { config, options, master });
-    const cors = require('cors');
-    log.info('Setting up CORS rules...');
-    const whitelist = config.get('cors');
-    log.info('Whitelist: ', whitelist.join(', '));
-    let corsOptions = {
-      origin: InitCORS.getOriginFilter(whitelist),
-      credentials: true
-    };
-    log.info('CORS options', corsOptions);
-    master.getServer().use(cors(corsOptions));
-    await ADDS.run('cors.post', { config, options, master });
-  }
+module.exports = class InitCORS {
+    static getOriginFilter(whitelist) {
+        return (origin, callback) => {
+            callback(null, whitelist.includes(origin));
+        };
+    }
 
+    async run({ config, options, master }) {
+        await ADDS.run("cors.pre", { config, options, master });
+        const cors = require("cors");
+        log.info("Setting up CORS rules...");
+        const whitelist = config.get("cors");
+        log.info("Whitelist: ", whitelist.join(", "));
+        let corsOptions = {
+            origin: InitCORS.getOriginFilter(whitelist),
+            credentials: true,
+        };
+        log.info("CORS options", corsOptions);
+        master.getServer().use(cors(corsOptions));
+        await ADDS.run("cors.post", { config, options, master });
+    }
 };

package/src/init/db/index.js

@@ -1,50 +1,48 @@
-const path = require('path');
-const {objHas} = require('../../common');
+const path = require("path");
+const { objHas } = require("../../common");
 
-module.exports = class InitDB{
+module.exports = class InitDB {
+    static default = path.resolve(__dirname, "./mongoose.js");
 
-  static default = path.resolve(__dirname, './mongoose.js');
+    static drivers = {
+        ioredis: path.resolve(__dirname, "./ioredis.js"),
+        redis: path.resolve(__dirname, "./redis.js"),
+        mongoose: path.resolve(__dirname, "./mongoose.js"),
+    };
 
-  static drivers = {
-    'ioredis':        path.resolve(__dirname, './ioredis.js'),
-    'redis':        path.resolve(__dirname, './redis.js'),
-    'mongoose':     path.resolve(__dirname, './mongoose.js')
-  };
-
-  /**
-  * Returns constructor of DB driver
-  * @param {string} driver  name of db engine
-  * @return {Object}          class constructor or undefined
-  **/
-  static getConstructor(driver){
-    if(objHas(InitDB.drivers, driver)){
-      return require(InitDB.drivers[driver]);
-    }else{
-      return require(InitDB.default);
+    /**
+     * Returns constructor of DB driver
+     * @param {string} driver  name of db engine
+     * @return {Object}          class constructor or undefined
+     **/
+    static getConstructor(driver) {
+        if (objHas(InitDB.drivers, driver)) {
+            return require(InitDB.drivers[driver]);
+        } else {
+            return require(InitDB.default);
+        }
     }
-  }
 
-  /**
-  *  db = {
-  *  [db_driver_name_1]: options,
-  *  [db_driver_name_2]: options,
-  * }
-  * to get driver require('not-node').getEnv(db_driver_name_2)
-  * require('not-node').getEnv('mongoose')
-  * require('not-node').getEnv('redis')
-  **/
-  async run({master, config, options}) {
-    const conf = config.get('db');
-    for(let driver in conf){
-      const Constructor = InitDB.getConstructor(driver);
-      await new Constructor().run({
-        master,
-        config,
-        options,
-        conf: conf[driver],
-        alias: driver
-      });
+    /**
+     *  db = {
+     *  [db_driver_name_1]: options,
+     *  [db_driver_name_2]: options,
+     * }
+     * to get driver require('not-node').getEnv(db_driver_name_2)
+     * require('not-node').getEnv('mongoose')
+     * require('not-node').getEnv('redis')
+     **/
+    async run({ master, config, options }) {
+        const conf = config.get("db");
+        for (let driver in conf) {
+            const Constructor = InitDB.getConstructor(driver);
+            await new Constructor().run({
+                master,
+                config,
+                options,
+                conf: conf[driver],
+                alias: driver,
+            });
+        }
     }
-  }
-
 };

package/src/init/db/ioredis.js

@@ -1,23 +1,31 @@
-const log = require('not-log')(module, 'not-node//init');
-const ADDS = require('../additional');
-
-module.exports = class InitDBRedisIO{
-
-  static async initRedis({ conf, master, alias}) {
-    log.info('Setting up ioredis connection...');
-    const Redis = require('ioredis');
-    const redisClient = new Redis(conf);
-    redisClient.on('error', log.error);
-    master.setEnv(`db.${alias}`, redisClient);
-    log.log('redis client');
-  }
-
-  async run({config, options, master, conf, alias}){
-    await ADDS.run(`db.${alias}.pre`, {config, options, master, conf, alias});
-    await InitDBRedisIO.initRedis({conf, master, alias});
-    await ADDS.run(`db.${alias}.post`, {config, options, master, conf, alias});
-  }
-
+const log = require("not-log")(module, "not-node//init");
+const ADDS = require("../additional");
 
+module.exports = class InitDBRedisIO {
+    static async initRedis({ conf, master, alias }) {
+        log.info("Setting up ioredis connection...");
+        const Redis = require("ioredis");
+        const redisClient = new Redis(conf);
+        redisClient.on("error", log.error);
+        master.setEnv(`db.${alias}`, redisClient);
+        log.log("redis client");
+    }
 
+    async run({ config, options, master, conf, alias }) {
+        await ADDS.run(`db.${alias}.pre`, {
+            config,
+            options,
+            master,
+            conf,
+            alias,
+        });
+        await InitDBRedisIO.initRedis({ conf, master, alias });
+        await ADDS.run(`db.${alias}.post`, {
+            config,
+            options,
+            master,
+            conf,
+            alias,
+        });
+    }
 };

package/src/init/db/mongoose.js

@@ -1,37 +1,47 @@
-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 InitDBMongoose{
-
-  static fixMongooseOptions(opts){
-    let options = JSON.parse(JSON.stringify(opts));
-    delete options.host;
-    delete options.db;
-    return options;
-  }
-
-  static async initMongoose({ conf, master, alias}) {
-    const Increment = require('../../model/increment.js');
-    log.info('Setting up mongoose connection...');
-    const mongoose = require('mongoose');
-    mongoose.Promise = global.Promise;
-    await mongoose.connect(
-      conf.uri,
-      InitDBMongoose.fixMongooseOptions(conf.options)
-    );
-    log.info('Mongoose connected...');
-    if(conf.increment !== false){
-      Increment.init(mongoose);
+module.exports = class InitDBMongoose {
+    static fixMongooseOptions(opts) {
+        let options = JSON.parse(JSON.stringify(opts));
+        delete options.host;
+        delete options.db;
+        return options;
     }
-    master.setMongoose(mongoose);
-    master.setEnv(`db.${alias}`, mongoose);
-  }
 
-  async run({config, options, master, conf, alias}){
-    log.info(`db.${alias}.pre`);
-    await ADDS.run(`db.${alias}.pre`, {config, options, master, conf, alias});
-    await InitDBMongoose.initMongoose({conf, master, alias});
-    await ADDS.run(`db.${alias}.post`, {config, options, master, conf, alias});
-  }
+    static async initMongoose({ conf, master, alias }) {
+        const Increment = require("../../model/increment.js");
+        log.info("Setting up mongoose connection...");
+        const mongoose = require("mongoose");
+        mongoose.Promise = global.Promise;
+        await mongoose.connect(
+            conf.uri,
+            InitDBMongoose.fixMongooseOptions(conf.options)
+        );
+        log.info("Mongoose connected...");
+        if (conf.increment !== false) {
+            Increment.init(mongoose);
+        }
+        master.setMongoose(mongoose);
+        master.setEnv(`db.${alias}`, mongoose);
+    }
 
+    async run({ config, options, master, conf, alias }) {
+        log.info(`db.${alias}.pre`);
+        await ADDS.run(`db.${alias}.pre`, {
+            config,
+            options,
+            master,
+            conf,
+            alias,
+        });
+        await InitDBMongoose.initMongoose({ conf, master, alias });
+        await ADDS.run(`db.${alias}.post`, {
+            config,
+            options,
+            master,
+            conf,
+            alias,
+        });
+    }
 };

package/src/init/db/redis.js

@@ -1,49 +1,60 @@
-const {notError} = require('not-error');
-const log = require('not-log')(module, 'not-node//init');
-const ADDS = require('../additional');
-
-module.exports = class InitDBRedis{
-
-  static async initRedis({ conf, master, alias}) {
-    log.info('Setting up redis connection...');
-    const redis = require('redis');
-    const redisClient = redis.createClient(conf);
-    InitDBRedis.bindClientEvents({master, redisClient});
-    master.setEnv(`db.${alias}`, redisClient);
-  }
-
-  async run({config, options, master, conf, alias}){
-    await ADDS.run(`db.${alias}.pre`, {config, options, master, conf, alias});
-    await InitDBRedis.initRedis({conf, master, alias});
-    await ADDS.run(`db.${alias}.post`, {config, options, master, conf, alias});
-  }
-
-  static bindClientEvents({redisClient, master}){
-    redisClient.on('error', (err) => {
-      log.error('Redis client error: ', err);
-      master.getApp().report(new notError('Redis connection failed', {}, err));
-    });
-
-    redisClient.on('warning', (err) => {
-      log.error('Redis client warning: ', err);
-    });
-
-    redisClient.on('connect', function() {
-      log.info('Redis client connected to DB');
-    });
-
-    redisClient.on('ready', function() {
-      log.info('Redis client ready');
-    });
-
-    redisClient.on('reconnecting', function() {
-      log.info('Redis client reconnecting');
-    });
-
-    redisClient.on('end', function() {
-      log.info('Redis client closed connection');
-    });
-  }
-
-
+const { notError } = require("not-error");
+const log = require("not-log")(module, "not-node//init");
+const ADDS = require("../additional");
+
+module.exports = class InitDBRedis {
+    static async initRedis({ conf, master, alias }) {
+        log.info("Setting up redis connection...");
+        const redis = require("redis");
+        const redisClient = redis.createClient(conf);
+        InitDBRedis.bindClientEvents({ master, redisClient });
+        master.setEnv(`db.${alias}`, redisClient);
+    }
+
+    async run({ config, options, master, conf, alias }) {
+        await ADDS.run(`db.${alias}.pre`, {
+            config,
+            options,
+            master,
+            conf,
+            alias,
+        });
+        await InitDBRedis.initRedis({ conf, master, alias });
+        await ADDS.run(`db.${alias}.post`, {
+            config,
+            options,
+            master,
+            conf,
+            alias,
+        });
+    }
+
+    static bindClientEvents({ redisClient, master }) {
+        redisClient.on("error", (err) => {
+            log.error("Redis client error: ", err);
+            master
+                .getApp()
+                .report(new notError("Redis connection failed", {}, err));
+        });
+
+        redisClient.on("warning", (err) => {
+            log.error("Redis client warning: ", err);
+        });
+
+        redisClient.on("connect", function () {
+            log.info("Redis client connected to DB");
+        });
+
+        redisClient.on("ready", function () {
+            log.info("Redis client ready");
+        });
+
+        redisClient.on("reconnecting", function () {
+            log.info("Redis client reconnecting");
+        });
+
+        redisClient.on("end", function () {
+            log.info("Redis client closed connection");
+        });
+    }
 };