not-node 5.0.22 → 5.1.2

package/src/init/env.js

@@ -1,42 +1,50 @@
-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 InitENV{
-
-  static getProxyPort(config){
-    return parseInt(config.get('proxy:port') || config.get('port'));
-  }
-
-  static getFullServerName(config){
-    let name = '';
-    if (config.get('proxy:secure') === true){
-      name='https://';
-    }else{
-      name='http://';
-    }
-    name+=config.get('host');
-    let proxyPort = InitENV.getProxyPort(config);
-    if(proxyPort !== 80){
-      name+= (':'+proxyPort);
+module.exports = class InitENV {
+    static getProxyPort(config) {
+        return parseInt(config.get("proxy:port") || config.get("port"));
     }
-    return name;
-  }
 
-
-  async run({config, options, master}) {
-    log.info('Setting up server environment variables...');
-    await ADDS.run('env.pre', {config, options, master});
-    config.set('staticPath',  master.getAbsolutePath(config.get('path:static') || 'static'));
-    config.set('modulesPath', master.getAbsolutePath(config.get('path:modules') || 'modules'));
-    config.set('dbDumpsPath', master.getAbsolutePath(config.get('path:dbDumps') || '../../db.dumps'));
-    config.set('appPath', options.pathToApp);
-    config.set('npmPath', options.pathToNPM);
-    config.set('fullServerName', InitENV.getFullServerName(config));
-    if(config.get('path:ws')){
-      log.log('wsPath', master.getAbsolutePath(config.get('path:ws')));
-      config.set('wsPath', master.getAbsolutePath(config.get('path:ws')));
+    static getFullServerName(config) {
+        let name = "";
+        if (config.get("proxy:secure") === true) {
+            name = "https://";
+        } else {
+            name = "http://";
+        }
+        name += config.get("host");
+        let proxyPort = InitENV.getProxyPort(config);
+        if (proxyPort !== 80) {
+            name += ":" + proxyPort;
+        }
+        return name;
     }
-    await ADDS.run('env.post', {config, options, master});
-  }
 
+    async run({ config, options, master }) {
+        log.info("Setting up server environment variables...");
+        await ADDS.run("env.pre", { config, options, master });
+        config.set(
+            "staticPath",
+            master.getAbsolutePath(config.get("path:static") || "static")
+        );
+        config.set(
+            "modulesPath",
+            master.getAbsolutePath(config.get("path:modules") || "modules")
+        );
+        config.set(
+            "dbDumpsPath",
+            master.getAbsolutePath(
+                config.get("path:dbDumps") || "../../db.dumps"
+            )
+        );
+        config.set("appPath", options.pathToApp);
+        config.set("npmPath", options.pathToNPM);
+        config.set("fullServerName", InitENV.getFullServerName(config));
+        if (config.get("path:ws")) {
+            log.log("wsPath", master.getAbsolutePath(config.get("path:ws")));
+            config.set("wsPath", master.getAbsolutePath(config.get("path:ws")));
+        }
+        await ADDS.run("env.post", { config, options, master });
+    }
 };

package/src/init/express.js

@@ -1,24 +1,21 @@
+const emit = require("./additional").run;
+const Log = require("not-log")(module, "not-node//init");
 
-const emit = require('./additional').run;
-const Log = require('not-log')(module, 'not-node//init');
-
-module.exports = class InitExpress{
-
-  static requestLogging({/*config, options, */master}){
-    master.getServer().use((req, res, next) => {
-      Log.log(req.ip, req.method, req.url);
-      return next();
-    });
-  }
-
-  async run({options, config, master}) {
-    Log.info('Init express app...');
-    await emit('express.pre', {options, config, master});
-    //express
-    const express = require('express');
-    master.setServer(express());
-    InitExpress.requestLogging({options, config, master});
-    await emit('express.post', {options, config, master});
-  }
+module.exports = class InitExpress {
+    static requestLogging({ /*config, options, */ master }) {
+        master.getServer().use((req, res, next) => {
+            Log.log(req.ip, req.method, req.url);
+            return next();
+        });
+    }
 
+    async run({ options, config, master }) {
+        Log.info("Init express app...");
+        await emit("express.pre", { options, config, master });
+        //express
+        const express = require("express");
+        master.setServer(express());
+        InitExpress.requestLogging({ options, config, master });
+        await emit("express.post", { options, config, master });
+    }
 };

package/src/init/fileupload.js

@@ -1,12 +1,10 @@
 module.exports = class InitFileupload {
-  async run({ /*options, config,*/
-    master
-  }) {
-    const fileUpload = require('express-fileupload');
-    master.getServer().use(
-      fileUpload({
-        createParentPath: true
-      })
-    );
-  }
+    async run({ /*options, config,*/ master }) {
+        const fileUpload = require("express-fileupload");
+        master.getServer().use(
+            fileUpload({
+                createParentPath: true,
+            })
+        );
+    }
 };

package/src/init/http.js

@@ -1,55 +1,73 @@
-const log = require('not-log')(module, 'not-node//init');
-const fs = require('fs');
-const ADDS = require('./additional');
+const log = require("not-log")(module, "not-node//init");
+const fs = require("fs");
+const ADDS = require("./additional");
 
-module.exports = class InitHTTP{
-
-  listenPromise({config, master}){
-    return new Promise((resolve, reject)=>{
-      master.getHTTPServer().listen(config.get('port'), (err) => {
-        if(err){reject(err);}
-        log.info('Server listening on port ' + config.get('port') + '.' + (InitHTTP.isSecure({config})?' For secure connections':''));
-        resolve();
-      });
-    });
-  }
-
-  static getSSLOptions({config}){
-    return {
-      key: fs.readFileSync(config.get('ssl:keys:private'), {encoding: 'utf-8'}),
-      cert: fs.readFileSync(config.get('ssl:keys:cert'), {encoding: 'utf-8'}), //fullchain
-      ca: fs.readFileSync(config.get('ssl:keys:chain'), {encoding: 'utf-8'})
-    };
-  }
+module.exports = class InitHTTP {
+    listenPromise({ config, master }) {
+        return new Promise((resolve, reject) => {
+            master.getHTTPServer().listen(config.get("port"), (err) => {
+                if (err) {
+                    reject(err);
+                }
+                log.info(
+                    "Server listening on port " +
+                        config.get("port") +
+                        "." +
+                        (InitHTTP.isSecure({ config })
+                            ? " For secure connections"
+                            : "")
+                );
+                resolve();
+            });
+        });
+    }
 
-  async runHTTPS({config, master}){
-    log.info('Setting up HTTPS server...');
-    const https = require('https');
-    master.getServer().set('protocol', 'https');
-    master.setHTTPServer(https.createServer(InitHTTP.getSSLOptions({config}), master.getServer()));
-    await this.listenPromise({config, master});
-  }
+    static getSSLOptions({ config }) {
+        return {
+            key: fs.readFileSync(config.get("ssl:keys:private"), {
+                encoding: "utf-8",
+            }),
+            cert: fs.readFileSync(config.get("ssl:keys:cert"), {
+                encoding: "utf-8",
+            }), //fullchain
+            ca: fs.readFileSync(config.get("ssl:keys:chain"), {
+                encoding: "utf-8",
+            }),
+        };
+    }
 
-  async runHTTP({config, master}){
-    log.info('Setting up HTTP server...');
-    const http = require('http');
-    master.getServer().set('protocol', 'http');
-    master.setHTTPServer(http.createServer(master.getServer()));
-    await this.listenPromise({config, master});
-  }
+    async runHTTPS({ config, master }) {
+        log.info("Setting up HTTPS server...");
+        const https = require("https");
+        master.getServer().set("protocol", "https");
+        master.setHTTPServer(
+            https.createServer(
+                InitHTTP.getSSLOptions({ config }),
+                master.getServer()
+            )
+        );
+        await this.listenPromise({ config, master });
+    }
 
-  static isSecure({config}){
-    return config.get('ssl:enabled') === true;
-  }
+    async runHTTP({ config, master }) {
+        log.info("Setting up HTTP server...");
+        const http = require("http");
+        master.getServer().set("protocol", "http");
+        master.setHTTPServer(http.createServer(master.getServer()));
+        await this.listenPromise({ config, master });
+    }
 
-  async run({options, config, master}) {
-    await ADDS.run('http.pre', {options, config, master});
-    if (InitHTTP.isSecure({config})) {
-      await this.runHTTPS({options, config, master});
-    } else {
-      await this.runHTTP({options, config, master});
+    static isSecure({ config }) {
+        return config.get("ssl:enabled") === true;
     }
-    await ADDS.run('http.post', {options, config, master});
-  }
 
+    async run({ options, config, master }) {
+        await ADDS.run("http.pre", { options, config, master });
+        if (InitHTTP.isSecure({ config })) {
+            await this.runHTTPS({ options, config, master });
+        } else {
+            await this.runHTTP({ options, config, master });
+        }
+        await ADDS.run("http.post", { options, config, master });
+    }
 };

package/src/init/index.js

@@ -1,15 +1,15 @@
 //
-const os = require('os');
-const path = require('path');
-const logger = require('not-log');
-const log = logger(module, 'not-node:Init');
+const os = require("os");
+const path = require("path");
+const logger = require("not-log");
+const log = logger(module, "not-node:Init");
 
-const Env = require('../env');
+const Env = require("../env");
 //
-const ADDS = require('./additional');
+const ADDS = require("./additional");
 //
-const InitSequence = require('./sequence.js');
-const STANDART_INIT_SEQUENCE = require('./sequence.standart.js');
+const InitSequence = require("./sequence.js");
+const STANDART_INIT_SEQUENCE = require("./sequence.standart.js");
 
 /**
  *	@example <caption>Application initialization</caption>
@@ -27,147 +27,140 @@ const STANDART_INIT_SEQUENCE = require('./sequence.standart.js');
  *		.expose(ExpressApp);
  **/
 class Init {
-  static options = false;
-  static manifest = false;
-  static config = false;
-  static mongoose = false;
-  static notApp = false;
-  static server = false;
-  static httpServer = false;
-  static WSServer = false;
-  static WSClient = false;
-
-
-  static getAbsolutePath(subPath) {
-    return path.resolve(Init.options.pathToApp, subPath);
-  }
-
-  static setManifest(manifest) {
-    Init.manifest = manifest;
-  }
-
-  static getManifest() {
-    return Init.manifest;
-  }
-
-  static setMongoose(val) {
-    Init.mongoose = val;
-  }
-
-  static getMongoose() {
-    return Init.mongoose;
-  }
-
-  static setServer(val) {
-    Init.server = val;
-    return Init;
-  }
-
-  static getServer() {
-    return Init.server;
-  }
-
-  static setHTTPServer(val) {
-    Init.httpServer = val;
-    return Init;
-  }
-
-  static getHTTPServer() {
-    return Init.httpServer;
-  }
-
-  static setEnv(key, val) {
-    Env.setEnv(key, val);
-  }
-
-  static getEnv(key) {
-    return Env.getEnv(key);
-  }
-
-  static getApp() {
-    return Init.notApp;
-  }
-
-  static setApp(val) {
-    Init.notApp = val;
-    return Init;
-  }
-
-  static initConfig(config = false) {
-    if (!config) {
-      Init.config = require('not-config').createReader();
-    } else {
-      Init.config = config;
-    }
-  }
-
-  static getConfig() {
-    return Init.config;
-  }
-
-  static printOutManifest = () => {
-    log.debug('Manifest:');
-    log.debug(JSON.stringify(Init.notApp.getManifest(), null, 4));
-  };
-
-  /**
-   * Initalization of Application
-   *
-   * @param {Object} params hash with few possible object
-   * @param {Object} params.config  nconf like reader {get:(key)=>any, set:(key, value)=>void}
-   * @param {Object} params.options paths infrastructure options
-   * @param {Object} params.manifest application manifest
-   * @param {Object} params.additional pre/mid/post actions for every major step of initialization {stepName: {pre: async()=>void, post: async()=>void, [key: string]=> async()=>void}}
-   **/
-
-  static async run({
-    config,
-    options,
-    manifest,
-    additional
-  }) {
-    try {
-      log.info('Kick start app...'+ os.platform()+' '+os.arch());
-      ADDS.init(additional);
-      const initSequence = new InitSequence(STANDART_INIT_SEQUENCE);
-      await ADDS.run('pre', {
-        config,
-        options,
-        manifest,
-        additional,
-        initSequence //giving a chance to change init sequence
-      });
-      //setting basic resources
-      Init.options = options; // pathToApp, pathToNPM
-      Init.setManifest(manifest);
-      //adopting provided config store or initializing own
-      Init.initConfig(config);
-      //creating context for other init runners
-      const context = {
-        config: Init.getConfig(), //access to config
-        options, //options
-        master: Init //this class
-      };
-      //running all prepared initalizers with current context
-      await initSequence.run(context);
-      await ADDS.run('post', {
-        config,
-        options,
-        manifest,
-        master: Init
-      });
-      log.info('Application initalization finished');
-    } catch (e) {
-      Init.throwError(e.message, 1);
-    }
-  }
-
-  static throwError(errMsg = 'Fatal error', errCode = 1) {
-    log.error(errMsg);
-    log.log(`Exit process...with code ${errCode}`);
-    throw new Error(errMsg);
-  }
+    static options = false;
+    static manifest = false;
+    static config = false;
+    static mongoose = false;
+    static notApp = false;
+    static server = false;
+    static httpServer = false;
+    static WSServer = false;
+    static WSClient = false;
+
+    static getAbsolutePath(subPath) {
+        return path.resolve(Init.options.pathToApp, subPath);
+    }
+
+    static setManifest(manifest) {
+        Init.manifest = manifest;
+    }
+
+    static getManifest() {
+        return Init.manifest;
+    }
+
+    static setMongoose(val) {
+        Init.mongoose = val;
+    }
+
+    static getMongoose() {
+        return Init.mongoose;
+    }
+
+    static setServer(val) {
+        Init.server = val;
+        return Init;
+    }
+
+    static getServer() {
+        return Init.server;
+    }
+
+    static setHTTPServer(val) {
+        Init.httpServer = val;
+        return Init;
+    }
+
+    static getHTTPServer() {
+        return Init.httpServer;
+    }
+
+    static setEnv(key, val) {
+        Env.setEnv(key, val);
+    }
+
+    static getEnv(key) {
+        return Env.getEnv(key);
+    }
+
+    static getApp() {
+        return Init.notApp;
+    }
+
+    static setApp(val) {
+        Init.notApp = val;
+        return Init;
+    }
+
+    static initConfig(config = false) {
+        if (!config) {
+            Init.config = require("not-config").createReader();
+        } else {
+            Init.config = config;
+        }
+    }
+
+    static getConfig() {
+        return Init.config;
+    }
+
+    static printOutManifest = () => {
+        log.debug("Manifest:");
+        log.debug(JSON.stringify(Init.notApp.getManifest(), null, 4));
+    };
+
+    /**
+     * Initalization of Application
+     *
+     * @param {Object} params hash with few possible object
+     * @param {Object} params.config  nconf like reader {get:(key)=>any, set:(key, value)=>void}
+     * @param {Object} params.options paths infrastructure options
+     * @param {Object} params.manifest application manifest
+     * @param {Object} params.additional pre/mid/post actions for every major step of initialization {stepName: {pre: async()=>void, post: async()=>void, [key: string]=> async()=>void}}
+     **/
+
+    static async run({ config, options, manifest, additional }) {
+        try {
+            log.info("Kick start app..." + os.platform() + " " + os.arch());
+            ADDS.init(additional);
+            const initSequence = new InitSequence(STANDART_INIT_SEQUENCE);
+            await ADDS.run("pre", {
+                config,
+                options,
+                manifest,
+                additional,
+                initSequence, //giving a chance to change init sequence
+            });
+            //setting basic resources
+            Init.options = options; // pathToApp, pathToNPM
+            Init.setManifest(manifest);
+            //adopting provided config store or initializing own
+            Init.initConfig(config);
+            //creating context for other init runners
+            const context = {
+                config: Init.getConfig(), //access to config
+                options, //options
+                master: Init, //this class
+            };
+            //running all prepared initalizers with current context
+            await initSequence.run(context);
+            await ADDS.run("post", {
+                config,
+                options,
+                manifest,
+                master: Init,
+            });
+            log.info("Application initalization finished");
+        } catch (e) {
+            Init.throwError(e.message, 1);
+        }
+    }
 
+    static throwError(errMsg = "Fatal error", errCode = 1) {
+        log.error(errMsg);
+        log.log(`Exit process...with code ${errCode}`);
+        throw new Error(errMsg);
+    }
 }
 
 module.exports.Init = Init;

package/src/init/informer.js

@@ -1,11 +1,9 @@
-const log = require('not-log')(module, 'not-node//init');
+const log = require("not-log")(module, "not-node//init");
 
-module.exports = class InitInformer{
-  async run({master}){
-    log.log('try to create informer');
-    const {
-      Inform
-    } = require('not-inform');
-    master.getApp().informer = new Inform();
-  }
+module.exports = class InitInformer {
+    async run({ master }) {
+        log.log("try to create informer");
+        const { Inform } = require("not-inform");
+        master.getApp().informer = new Inform();
+    }
 };

package/src/init/methodoverride.js

@@ -1,8 +1,6 @@
 module.exports = class InitMethodOverride {
-  async run({ /*options, config,*/
-    master
-  }) {
-    const methodOverride = require('method-override');
-    master.getServer().use(methodOverride());
-  }
+    async run({ /*options, config,*/ master }) {
+        const methodOverride = require("method-override");
+        master.getServer().use(methodOverride());
+    }
 };