not-node 4.0.3 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "not-node",
-  "version": "4.0.3",
+  "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/init/db/ioredis.js

@@ -1,4 +1,3 @@
-const {notError} = require('not-error');
 const log = require('not-log')(module, 'not-node//init');
 const ADDS = require('../additional');
 

package/src/init/index.js

@@ -78,7 +78,7 @@ class Init {
   static setEnv(key, val) {
     Env.setEnv(key, val);
   }
-  
+
   static getEnv(key) {
     return Env.getEnv(key);
   }
@@ -149,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/routes.js

@@ -4,6 +4,7 @@ const serveStatic = require('serve-static');
 const log = require('not-log')(module, 'not-node//init');
 const {
   notError,
+  notValidationError,
   notRequestError
 } = require('not-error');
 
@@ -12,27 +13,39 @@ module.exports = class InitRoutes {
   static finalError({
     master
   }) {
-    return (err, req, res) => {
+    // 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 request params - ok, but result is not
         if (err instanceof notRequestError) {
           if (err.getRedirect()) {
-            res.redirect(err.getRedirect());
+            return res.redirect(err.getRedirect());
           } else {
-
-            res.status(err.getCode()).json({
+            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 {
         log.error('Unknown error:', err);

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/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){