not-node 4.0.0 → 4.0.4

package/.eslintrc.json

@@ -31,6 +31,7 @@
     "node/prefer-global/url": ["error", "always"],
     "node/prefer-promises/dns": "error",
     "node/prefer-promises/fs": "error",
+    "node/no-unpublished-require": "warn",
     "indent": ["error", 2],
     "linebreak-style": [
       "error",

package/index.js

@@ -2,6 +2,7 @@
 * @module not-node
 */
 
+module.exports.Env = require('./src/env.js');
 /** Error module
  * @type {not-node/Error}
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "not-node",
-  "version": "4.0.0",
+  "version": "4.0.4",
   "description": "node complimentary part for client side notFramework.",
   "main": "index.js",
   "scripts": {
@@ -78,6 +78,7 @@
     "eslint-plugin-promise": "^5.1.1",
     "eslint-plugin-sonarjs": "^0.10.0",
     "ink-docstrap": "^1.3.2",
+    "ioredis": "^4.28.1",
     "jsdoc": "^3.6.7",
     "mocha": "*",
     "mocha-suppress-logs": "^0.3.1",

package/src/domain.js

@@ -4,8 +4,9 @@
  *
  */
 const EventEmitter = require('events');
-const {executeObjectFunction, objHas, firstLetterToUpper} = require('./common');
+const {isFunc,isAsync, objHas, firstLetterToUpper} = require('./common');
 
+const Env = require('./env');
 const
   notModule = require('./manifest/module'),
   path = require('path'),
@@ -250,7 +251,13 @@ class notDomain extends EventEmitter {
   async execInModules(methodName) {
     for (let mod of Object.values(this.modules)) {
       try{
-        await executeObjectFunction(mod, 'exec', [methodName]);
+        if(isFunc(mod.exec)){
+          if(isAsync(mod.exec)){
+            await mod.exec(methodName);
+          }else{
+            mod.exec(methodName);
+          }
+        }
       }catch(e){
         this.report(e);
       }
@@ -267,30 +274,6 @@ class notDomain extends EventEmitter {
     }
   }
 
-  /**
-   *  Returns application environment variable
-   *  @param   {string}      key  name of var
-   *  @return {object|undefined}    value or undefined
-   */
-  getEnv(key) {
-    if (objHas(this.envs,key)) {
-      return this.envs[key];
-    } else {
-      return undefined;
-    }
-  }
-
-  /**
-   *  Setting application environment variable
-   *  @param   {string}      key  name of var
-   *  @param   {object}      val  value
-   *  @return {notDomain}      chainable
-   */
-  setEnv(key, val) {
-    this.envs[key] = val;
-    return this;
-  }
-
   /**
    *  logger
    */
@@ -443,6 +426,21 @@ class notDomain extends EventEmitter {
     return stats;
   }
 
+  getEnv(key) {
+    return Env.getEnv(key);
+  }
+
+  /**
+   *  Setting application environment variable
+   *  @param   {string}      key  name of var
+   *  @param   {object}      val  value
+   *  @return {notDomain}      chainable
+   */
+  static setEnv(key, val) {
+    Env.setEnv(key, val);
+    return this;
+  }
+
 }
 
 module.exports = notDomain;

package/src/env.js

@@ -0,0 +1,31 @@
+const {objHas} = require('./common');
+
+const ENVS = {
+  process: process.env.NODE_ENV || 'development'
+};
+
+module.exports = class notEnv {
+  /**
+   *  Returns application environment variable
+   *  @param   {string}      key  name of var
+   *  @return {object|undefined}    value or undefined
+   */
+  static getEnv(key) {
+    if (objHas(ENVS,key)) {
+      return ENVS[key];
+    } else {
+      return undefined;
+    }
+  }
+
+  /**
+   *  Setting application environment variable
+   *  @param   {string}      key  name of var
+   *  @param   {object}      val  value
+   *  @return {notDomain}      chainable
+   */
+  static setEnv(key, val) {
+    ENVS[key] = val;
+    return notEnv;
+  }
+};

package/src/init/app.js

@@ -21,13 +21,13 @@ module.exports = class InitApp{
 
   static async setAppEnvs({config, options, master}){
     await emit('app.setEnv.pre', {config, options, master});
-    master.getApp().setEnv('hostname', config.get('hostname'));
-    master.getApp().setEnv('server', `https://` + config.get('host'));
-    master.getApp().setEnv('appPath', config.get('appPath'));
-    master.getApp().setEnv('name', master.getManifest().name);
-    master.getApp().setEnv('fullServerName', config.get('fullServerName'));
-    master.getApp().setEnv('dbDumpsPath', config.get('dbDumpsPath'));
-    master.getApp().setEnv('rolesPriority', master.getManifest().targets.server.roles);
+    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});
   }

package/src/init/db/index.js

@@ -6,6 +6,7 @@ module.exports = class InitDB{
   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')
   };
@@ -28,9 +29,9 @@ module.exports = class InitDB{
   *  [db_driver_name_1]: options,
   *  [db_driver_name_2]: options,
   * }
-  * to get driver require('not-node').Application.getEnv(db_driver_name_2)
-  * require('not-node').Application.getEnv('mongoose')
-  * require('not-node').Application.getEnv('redis')
+  * 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');
@@ -40,7 +41,7 @@ module.exports = class InitDB{
         master,
         config,
         options,
-        conf,
+        conf: conf[driver],
         alias: driver
       });
     }

package/src/init/db/ioredis.js

@@ -0,0 +1,24 @@
+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');
+    log.log(Object.keys(redisClient));
+  }
+
+  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

@@ -24,7 +24,7 @@ module.exports = class InitDBMongoose{
       Increment.init(mongoose);
     }
     master.setMongoose(mongoose);
-    master.getApp().setEnv(`db.${alias}`, mongoose);
+    master.setEnv(`db.${alias}`, mongoose);
   }
 
   async run({config, options, master, conf, alias}){

package/src/init/db/redis.js

@@ -9,7 +9,7 @@ module.exports = class InitDBRedis{
     const redis = require('redis');
     const redisClient = redis.createClient(conf);
     InitDBRedis.bindClientEvents({master, redisClient});
-    master.getApp().setEnv(`db.${alias}`, redisClient);
+    master.setEnv(`db.${alias}`, redisClient);
   }
 
   async run({config, options, master, conf, alias}){

package/src/init/index.js

@@ -2,6 +2,8 @@
 const path = require('path');
 const logger = require('not-log');
 const log = logger(module, 'not-node:Init');
+
+const Env = require('../env');
 //
 const ADDS = require('./additional');
 //
@@ -9,21 +11,21 @@ const InitSequence = require('./sequence.js');
 const STANDART_INIT_SEQUENCE = require('./sequence.standart.js');
 
 /**
-*	@example <caption>Application initialization</caption>
-*	let App = new notApp({
-*		mongoose: mongooseLink
-*		modulesCollectionPaths: [__dirname + '/modules'], //each path to folder with modules
-*		modulesPaths: [],	//each path to module
-*		modules: {
-*			filestore: require('not-filestore') //each npm not-* module with custom overriden name as key
-*		}
-*	})
-*		.importModuleFrom(__dirname+'/anotherModule', 'anotherCustomModuleName')	//import module from path
-*		.importModulesFrom(__dirname+'/directoryOfUsefullessModules')
-*		.importModule(require('notModule'), 'notModule')
-*		.expose(ExpressApp);
-**/
-class Init{
+ *	@example <caption>Application initialization</caption>
+ *	let App = new notApp({
+ *		mongoose: mongooseLink
+ *		modulesCollectionPaths: [__dirname + '/modules'], //each path to folder with modules
+ *		modulesPaths: [],	//each path to module
+ *		modules: {
+ *			filestore: require('not-filestore') //each npm not-* module with custom overriden name as key
+ *		}
+ *	})
+ *		.importModuleFrom(__dirname+'/anotherModule', 'anotherCustomModuleName')	//import module from path
+ *		.importModulesFrom(__dirname+'/directoryOfUsefullessModules')
+ *		.importModule(require('notModule'), 'notModule')
+ *		.expose(ExpressApp);
+ **/
+class Init {
   static options = false;
   static manifest = false;
   static config = false;
@@ -34,14 +36,19 @@ class Init{
   static WSServer = false;
   static WSClient = false;
 
-  static getAbsolutePath(subPath, options){
-    return path.resolve(options.pathToApp, subPath);
+
+  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;
   }
@@ -50,29 +57,37 @@ class Init{
     return Init.mongoose;
   }
 
-  static setServer(val){
+  static setServer(val) {
     Init.server = val;
     return Init;
   }
 
-  static getServer(){
+  static getServer() {
     return Init.server;
   }
 
-  static setHTTPServer(val){
+  static setHTTPServer(val) {
     Init.httpServer = val;
     return Init;
   }
 
-  static getHTTPServer(){
+  static getHTTPServer() {
     return Init.httpServer;
   }
 
-  static getApp(){
+  static setEnv(key, val) {
+    Env.setEnv(key, val);
+  }
+
+  static getEnv(key) {
+    return Env.getEnv(key);
+  }
+
+  static getApp() {
     return Init.notApp;
   }
 
-  static setApp(val){
+  static setApp(val) {
     Init.notApp = val;
     return Init;
   }
@@ -134,6 +149,11 @@ class Init{
       };
       //running all prepared initalizers with current context
       await initSequence.run(context);
+      await ADDS.run('post', {
+        config,
+        options,
+        manifest
+      });
       log.info('Application initalization finished');
     } catch (e) {
       Init.throwError(e.message, 1);

package/src/init/middleware.js

@@ -18,7 +18,9 @@ module.exports = class InitMiddleware{
         } else {
           proc = require(warePath);
         }
-        master.getServer().use(proc);
+        if(typeof proc === 'function'){
+          master.getServer().use(proc);
+        }
       }
     }
     await ADDS.run('middleware.post', {config, options, master});

package/src/init/rateLimiter.js

@@ -27,7 +27,7 @@ module.exports = class InitRateLimiter{
   static createRateLimiter({master}){
     const {RateLimiterRedis} = require('rate-limiter-flexible');
     return new RateLimiterRedis({
-      storeClient:  master.getApp().getEnv('db.redis'),
+      storeClient:  master.getEnv('db.redis'),
       keyPrefix:    'middleware',
       points:       10,     // 10 requests
       duration:     1,    // per 1 second by IP

package/src/init/routes.js

@@ -2,34 +2,52 @@
 
 const serveStatic = require('serve-static');
 const log = require('not-log')(module, 'not-node//init');
-const {notError, notRequestError} = require('not-error');
+const {
+  notError,
+  notValidationError,
+  notRequestError
+} = require('not-error');
 
 module.exports = class InitRoutes {
 
-  static finalError({master}){
-    return (err, req, res) => {
-      if(err instanceof notError){
+  static finalError({
+    master
+  }) {
+    // eslint-disable-next-line no-unused-vars
+    return (err, req, res, next) => {
+      //reportable errors from known cases
+      if (err instanceof notError) {
         master.getApp().report(err);
-        if(err instanceof notRequestError){
-          if(err.getRedirect()){
-            res.redirect(err.getRedirect());
-          }else{
-
-            res.status(err.getCode()).json({
+        //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',
-              error: err.getResult().message,
+              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()
+          });
         }
-      }else if (err instanceof Error && (res && res.status && res.json)){
+      }
+      //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',
-          error: err.message
+          message: err.message
         });
-      }else{
+      } else {
         log.error('Unknown error:', err);
         res.status(500).json({
           status: 'error'
@@ -38,13 +56,19 @@ module.exports = class InitRoutes {
     };
   }
 
-  async run({master, config, options}) {
+  async run({
+    master,
+    config,
+    options
+  }) {
     log.info('Setting up routes...');
     master.getApp().expose(master.getServer());
     require(options.routesPath)(master.getServer(), master.getApp());
-    master.getApp().use(serveStatic(config.get('staticPath')));
-    master.getApp().use(options.indexRoute);
-    master.getApp().use(InitRoutes.finalError({master}));
+    master.getServer().use(serveStatic(config.get('staticPath')));
+    master.getServer().use(options.indexRoute);
+    master.getServer().use(InitRoutes.finalError({
+      master
+    }));
   }
 
 };

package/src/init/sessions/mongoose.js

@@ -5,7 +5,7 @@ const ADDS = require('../additional');
 module.exports = class InitSessionsMongo{
   static createStore({config, master, expressSession}){
     const MongoDBStore = require('connect-mongodb-session')(expressSession);
-    const mongooseOptions = config.get('mongoose.options');
+    const mongooseOptions = config.get('db.mongoose.options');
     let store = new MongoDBStore({
       uri: `mongodb://${mongooseOptions.user}:${mongooseOptions.pass}@${mongooseOptions.host}/${mongooseOptions.db}`,
       databaseName: mongooseOptions.db,

package/src/init/sessions/redis.js

@@ -6,7 +6,7 @@ module.exports = class InitSessionsRedis{
     log.info('Setting up user sessions handler(redis)...');
     await ADDS.run('sessions.pre', {config, options, master});
     const expressSession = require('express-session');
-    const redisClient = master.getApp().getEnv('db.redis');
+    const redisClient = master.getEnv('db.redis');
     const redisStore = require('connect-redis')(expressSession);
     master.getServer().use(expressSession({
       secret:             config.get('session:secret'),

package/src/manifest/module.js

@@ -164,7 +164,6 @@ class notModule {
     }
   }
 
-
   getModelSchema(modelName) {
     let modelFile = this.getModelFile(modelName);
     if (modelFile && objHas(modelFile, modelName) && modelFile.thisSchema) {
@@ -285,6 +284,10 @@ class notModule {
     this.routes[key] = val;
   }
 
+  setLogic(key, val){
+    this.logics[key] = val;
+  }
+
   getRoute(routeName) {
     if (this.routes && objHas(this.routes, routeName)) {
       return this.routes[routeName];

package/src/manifest/registrator/routes.js

@@ -167,7 +167,7 @@ module.exports = class notModuleRegistratorRoutes{
     });
   }
 
-  static registerManifest({nModule, manifest, routeName}) {
-    nModule.setManifest(routeName, manifest);
+  static registerManifest({nModule, routeManifest, routeName}) {
+    nModule.setManifest(routeName, routeManifest);
   }
 };

package/src/manifest/route.js

@@ -133,11 +133,41 @@ class notRoute{
     );
   }
 
+  extractReturn(notRouteData){
+    if(objHas(notRouteData.rule, 'return')){
+      return [...notRouteData.rule.return];
+    }else if(objHas(notRouteData.actionData, 'return')){
+      return [...notRouteData.actionData.return];
+    }else{
+      return undefined;
+    }
+  }
+
+  /**
+  * Removes fields from result object acctoding to actionData.return array
+  * if presented
+  * @param {ExpressRequest} req request object
+  * @param {object} result result returned by main action processor
+  **/
+  filterResultByReturnRule(req, result){
+    const returnList = this.extractReturn(req.notRouteData);
+    if(result && (typeof result === 'object') && returnList && Array.isArray(returnList)){
+      let presented = Object.keys(result);
+      presented.forEach(fieldName => {
+        if(!returnList.includes(fieldName)){
+          delete result[fieldName];
+        }
+      });
+    }
+  }
+
   async executeRoute(modRoute, actionName, {req, res, next}){
     //waiting preparation
     let prepared = await this.executeFunction(modRoute, CONST_BEFORE_ACTION, [req, res, next]);
     //waiting results
     let result = await this.executeFunction(modRoute, actionName, [req, res, next, prepared]);
+    //filter result IF actionData.return specified
+    this.filterResultByReturnRule(req, result);
     //run after with results, continue without waiting when it finished
     return this.executeFunction(modRoute, CONST_AFTER_ACTION, [req, res, next, result]);
   }

package/src/model/proto.js

@@ -54,10 +54,9 @@ module.exports = class ModelFabricate{
     if (targetModule.thisStatics) {
       Object.assign(schema.statics, targetModule.thisStatics);
     }
-    this.extendSchemaFrom(targetModule.thisVirtuals, schema.virtual);
-    this.extendSchemaFrom(targetModule.thisPre, schema.pre);
-    this.extendSchemaFrom(targetModule.thisPost, schema.post);
-
+    this.extendSchemaFrom(targetModule.thisVirtuals, schema.virtual.bind(schema));
+    this.extendSchemaFrom(targetModule.thisPre, schema.pre.bind(schema));
+    this.extendSchemaFrom(targetModule.thisPost, schema.post.bind(schema));
   }
 
   static enrichByFields(targetModule){

package/test/env.js

@@ -0,0 +1,24 @@
+const expect = require('chai').expect,
+	Env = require('../src/env');
+
+describe('Env', function() {
+	describe('getEnv', function() {
+		it('key exists', function() {
+			const res = Env.getEnv('process');
+			expect(res).to.be.equal('development');
+		});
+
+		it('key not exists', function() {
+			const res = Env.getEnv('key' + Math.random().toString());
+			expect(res).to.be.undefined;
+		});
+	});
+
+	describe('setEnv', function() {
+		it('set', function() {
+			const res = Env.setEnv('key', 'happy');
+			expect(res).to.be.deep.equal(Env);
+			expect(res.getEnv('key')).to.be.deep.equal('happy');
+		});
+	});
+});

package/test/init/app.js

@@ -106,6 +106,9 @@ module.exports = ({expect})=>{
           },
           getManifest(){
             return fakeManifest;
+          },
+          setEnv(){
+
           }
         };
 
@@ -332,7 +335,6 @@ module.exports = ({expect})=>{
          };
         const options = {fake: 'options'};
         const fakeApp = {
-
           setEnv(){},
           importModulesFrom(modsPath){
             expect(modsPath).to.be.equal('modulesPath_fake');
@@ -342,6 +344,7 @@ module.exports = ({expect})=>{
           }
         };
         const master = {
+          setEnv(){},
           setApp(app){expect(app).to.be.instanceof(FakeApp);},
           throwError(e){
             throw new Error(e)

package/test/init/routes.js

@@ -17,7 +17,7 @@ module.exports = ({expect})=>{
           json(dat){
             expect(dat).to.be.deep.equal({
               status: 'error',
-              error: 'Serious generic error'
+              message: 'Serious generic error'
             });
             done();
           }
@@ -120,7 +120,7 @@ module.exports = ({expect})=>{
           json(dat){
             expect(dat).to.be.deep.equal({
               status: 'error',
-              error:  'Serious not error request',
+              message:  'Serious not error request',
               errors:  {field: ['name']},
             });
             done();
@@ -142,8 +142,10 @@ module.exports = ({expect})=>{
 
 
     describe('run', ()=>{
-      it('', async ()=>{
-        const fakeServer = { sarver: true};
+      it('run', async ()=>{
+        const fakeServer = { sarver: true, use(fn){
+          expect(typeof fn).to.be.equal('function');
+        }};
         const fakeApp = {
           report(){},
           use(fn){

package/test/init/sessions/redis.js

@@ -38,6 +38,9 @@ module.exports = ({
         };
 
         const master = {
+          getEnv(){
+
+          },
           getServer(){
             return {
               use(arg){

package/test/notDomain.js

@@ -507,36 +507,7 @@ describe('notDomain', function() {
   });
 
 
-  describe('getEnv', function() {
-    it('key exists', function() {
-      const ctx = {
-        envs:{
-          key: 'happy'
-        }
-      };
-      const res = notDomain.prototype.getEnv.call(ctx, 'key');
-      expect(res).to.be.equal('happy');
-    });
-    it('key not exists', function() {
-      const ctx = {
-        envs:{
-        }
-      };
-      const res = notDomain.prototype.getEnv.call(ctx, 'key');
-      expect(res).to.be.undefined;
-    });
-  });
 
-  describe('setEnv', function() {
-    it('set', function() {
-      const ctx = {
-        envs:{}
-      };
-      const res = notDomain.prototype.setEnv.call(ctx, 'key', 'happy');
-      expect(res).to.be.deep.equal(ctx);
-      expect(res.envs.key).to.be.deep.equal('happy');
-    });
-  });
 
 
   describe('logger', function() {

package/test/notInit.js

@@ -7,9 +7,10 @@ describe('initialization', function() {
   describe('notInit', ()=>{
     describe('getAbsolutePath', ()=>{
       it('all set', ()=>{
-        const res = Init.getAbsolutePath('../src/index', {
+        Init.options = {
           pathToApp: '/home/admin/server/test'
-        });
+        };
+        const res = Init.getAbsolutePath('../src/index', );
         expect(res).to.be.equal('/home/admin/server/src/index');
       });
     });