not-node 4.0.11 → 4.0.16

package/index.js

@@ -30,7 +30,9 @@ module.exports.Common = require('./src/common');
 /** Fields library manager */
 module.exports.Fields = require('./src/fields');
 /** Form validation template **/
-module.exports.Form = require('./src/form');
+module.exports.Form = require('./src/form').Form;
+/** Form validation template fabric **/
+module.exports.FormFabric = require('./src/form').FormFabric;
 /** Application initialization procedures */
 module.exports.Init = require('./src/init').Init;
 /** Application object */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "not-node",
-  "version": "4.0.11",
+  "version": "4.0.16",
   "description": "node complimentary part for client side notFramework.",
   "main": "index.js",
   "scripts": {
@@ -63,6 +63,7 @@
     "not-path": "*",
     "rate-limiter-flexible": "^2.3.6",
     "redis": "^4.0.0",
+    "rfdc": "^1.3.0",
     "rmdir": "^1.2.0",
     "serve-static": "*",
     "simple-git": "*",
@@ -73,7 +74,7 @@
     "babel-eslint": "^10.1.0",
     "chai": "*",
     "chai-as-promised": "*",
-    "eslint": "^8.3.0",
+    "eslint": "^7.0.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^5.2.0",
     "eslint-plugin-sonarjs": "^0.11.0",

package/src/common.js

@@ -92,6 +92,21 @@ module.exports.copyObj = (obj) => {
   return JSON.parse(JSON.stringify(obj));
 };
 
+/**
+* Copies object to secure it from changes
+* @param {object}   obj     original object
+* @return {object}          copy of object
+**/
+module.exports.partCopyObj = (obj, list) => {
+  let partObj =  Object.keys(obj).reduce((prev, curr)=>{
+    if(list.includes(curr)){
+      prev[curr] = obj[curr];
+    }
+    return prev;
+  }, {});
+  return JSON.parse(JSON.stringify(partObj));
+};
+
 
 /**
 * Test argument type to be 'function'

package/src/fields/index.js

@@ -1,3 +1,4 @@
+const clone = require('rfdc')();
 const fs = require('fs');
 const path = require('path');
 const {objHas, tryFile} = require('../common');
@@ -82,7 +83,7 @@ module.exports.initField = (field, resultOnly = true, type = 'ui') => {
     destName = srcName = field;
   }
   let proto = (objHas(FIELDS, srcName) && objHas(FIELDS[srcName], type)) ? FIELDS[srcName][type]:{};
-  let result = Object.assign({}, proto, mutation);
+  let result = Object.assign({}, clone(proto), mutation);
   if (resultOnly) {
     return result;
   } else {

package/src/form/fabric.js

@@ -0,0 +1,28 @@
+const Form = require('./form');
+
+module.exports = class FormFabric {
+  static create({
+    FIELDS,
+    MODULE_NAME,
+    FORM_NAME,
+    extractor
+  }) {
+    return class extends Form {
+      constructor() {
+        super({
+          FIELDS,
+          FORM_NAME: `${MODULE_NAME}:${FORM_NAME}`
+        });
+      }
+
+      /**
+       * Extracts data
+       * @param {ExpressRequest} req expressjs request object
+       * @return {Object}        forma data
+       **/
+      extract(req) {
+        return extractor(req);
+      }
+    };
+  }
+};

package/src/form/form.js

@@ -0,0 +1,105 @@
+//DB related validation tools
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+//not-node
+const initFields = require('../fields').initFields;
+
+const FormFabric = require('./fabric');
+
+const {
+  byFieldsValidators
+} = require('../model/enrich');
+
+const {
+  notValidationError,
+  notError
+} = require('not-error');
+
+
+/**
+ * Generic form validation class
+ **/
+class Form {
+  constructor({
+    FIELDS,
+    FORM_NAME
+  }) {
+    this.FORM_NAME = FORM_NAME;
+    this.PROTO_FIELDS = FIELDS;
+    if (mongoose.modelNames().indexOf(FORM_NAME)===-1){
+      this.SCHEMA = byFieldsValidators(initFields(this.PROTO_FIELDS, 'model'));
+      this.MODEL = mongoose.model(FORM_NAME, Schema(this.SCHEMA));
+    }else{
+      this.MODEL = mongoose.connection.model(FORM_NAME);
+      this.SCHEMA = this.MODEL.schema;
+    }
+  }
+
+  getFields(){
+    return Object.keys(this.SCHEMA);
+  }
+
+  /**
+   * Extract data from ExpressRequest object and validates it
+   * returns it or throws
+   * @param {ExpressRequest} req expressjs request object
+   * @return {Promise<Object>} form data
+   * @throws {notValidationError}
+   **/
+  async run(req) {
+    let data = await this.extract(req);
+    await this._validate(data);
+    return data;
+  }
+
+  /**
+   * Extracts data, should be overriden
+   * @param {ExpressRequest} req expressjs request object
+   * @return {Object}        forma data
+   **/
+  async extract( /*req*/ ) {
+    return {};
+  }
+
+  /**
+   * Validates form data or throws
+   * @param {Object} data    form data
+   * @return {Object}
+   * @throws {notValidationError}
+   **/
+  async _validate(data) {
+    try {
+      await this.validate(data);
+    } catch (e) {
+      let fields = {};
+      if (e instanceof mongoose.Error.ValidationError) {
+        Object.keys(e.errors).forEach(name => {
+          fields[name] = [e.errors[name].message];
+        });
+        throw new notValidationError(e.message, fields, e, data);
+      } else if (e instanceof notValidationError){
+        throw e;
+      }else {
+        throw new notError(
+          'core:form_validation_error', {
+            FORM_NAME: this.FORM_NAME,
+            PROTO_FIELDS: this.PROTO_FIELDS,
+            FORM_FIELDS: this.getFields(),
+            data
+          },
+          e
+        );
+      }
+    }
+  }
+
+  async validate(data){
+    await this.MODEL.validate(data, this.getFields());
+  }
+
+  static fabric(){
+    return FormFabric;
+  }
+}
+
+module.exports = Form;

package/src/form/index.js

@@ -1,82 +1,4 @@
-//DB related validation tools
-const mongoose = require('mongoose');
-const Schema = mongoose.Schema;
-//not-node
-const initFields = require('../fields').initFields;
-const {
-  byFieldsValidators
-} = require('../model/enrich');
-const {
-  notValidationError,
-  notError
-} = require('not-error');
-
-/**
- * Generic form validation class
- **/
-module.exports = class Form {
-  constructor({
-    FIELDS,
-    FORM_NAME
-  }) {
-    this.FORM_NAME = FORM_NAME;
-    this.FIELDS = FIELDS;
-    this.SCHEMA = byFieldsValidators(initFields(FIELDS, 'model'));
-    if (mongoose.modelNames().indexOf(FORM_NAME)===-1){
-      this.MODEL = mongoose.model(FORM_NAME, Schema(this.SCHEMA));
-    }else{
-      this.MODEL = mongoose.connection.model(FORM_NAME);
-    }
-  }
-
-  /**
-   * Extract data from ExpressRequest object and validates it
-   * returns it or throws
-   * @param {ExpressRequest} req expressjs request object
-   * @return {Promise<Object>} form data
-   * @throws {notValidationError}
-   **/
-  async run(req) {
-    let data = await this.extract(req);
-    await this.validate(data);
-    return data;
-  }
-
-  /**
-   * Extracts data, should be overriden
-   * @param {ExpressRequest} req expressjs request object
-   * @return {Object}        forma data
-   **/
-  async extract( /*req*/ ) {
-    return {};
-  }
-
-  /**
-   * Validates form data or throws
-   * @param {Object} data    form data
-   * @return {Object}
-   * @throws {notValidationError}
-   **/
-  async validate(data) {
-    try {
-      await this.MODEL.validate(data, this.FIELDS);
-    } catch (e) {
-      let fields = {};
-      if (e instanceof mongoose.Error.ValidationError) {
-        Object.keys(e.errors).forEach(name => {
-          fields[name] = [e.errors[name].message];
-        });
-        throw new notValidationError(e.message, fields, e, data);
-      } else {
-        throw new notError(
-          'core:form_validation_error', {
-            FORM_NAME: this.FORM_NAME,
-            FIELDS: this.FIELDS,
-            data
-          },
-          e
-        );
-      }
-    }
-  }
+module.exports = {
+  Form: require('./form'),
+  FormFabric: require('./fabric'),
 };

package/src/init/rateLimiter.js

@@ -1,5 +1,6 @@
 const emit = require('./additional').run;
 const log = require('not-log')(module, 'RateLimiter');
+const {partCopyObj} = require('../common');
 
 const DEFAULT_OPTIONS = {
   keyPrefix: 'rateLimiterMiddleware',
@@ -7,6 +8,8 @@ const DEFAULT_OPTIONS = {
   duration: 1
 };
 
+const DEFAULT_CLIENT = 'ioredis';
+
 module.exports = class InitRateLimiter{
 
   static createMiddleware({rateLimiter}){
@@ -29,18 +32,20 @@ module.exports = class InitRateLimiter{
   }
 
 
-  getOptions({config}){
+  static getOptions({config}){
+    const opts = partCopyObj(config.get('modules.rateLimiter', {}), Object.keys(DEFAULT_OPTIONS));
     return {
       ...DEFAULT_OPTIONS,
-      ...config.get('modules.rateLimiter', {})
+      ...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.redis'),
-      ...this.getOptions({master, config})
+      storeClient:  master.getEnv(`db.${storeClient}`),
+      ...InitRateLimiter.getOptions({master, config})
     });
   }
 };

package/src/init/sessions/redis.js

@@ -1,17 +1,20 @@
 const log = require('not-log')(module, 'not-node//init');
 const ADDS = require('../additional');
 
+const DEFAULT_CLIENT = 'ioredis';
+
 module.exports = class InitSessionsRedis{
   async run({config, options, master}) {
     log.info('Setting up user sessions handler(redis)...');
     await ADDS.run('sessions.pre', {config, options, master});
     const expressSession = require('express-session');
-    const redisClient = master.getEnv('db.redis');
+    const storeClient = config.get('session.client', DEFAULT_CLIENT);
+    const redisClient = master.getEnv(`db.${storeClient}`);
     const redisStore = require('connect-redis')(expressSession);
     master.getServer().use(expressSession({
-      secret:             config.get('session:secret'),
-      key:                config.get('session:key'),
-      cookie:             config.get('session:cookie'),
+      secret:             config.get('session.secret'),
+      key:                config.get('session.key'),
+      cookie:             config.get('session.cookie'),
       resave:             false,
       saveUninitialized:  true,
       store: new redisStore({

package/src/model/enrich.js

@@ -1,7 +1,7 @@
 /** @module Model/Enrich */
 
 const Schema = require('mongoose').Schema,
-  firstLetterToLower = require('../common').firstLetterToLower,
+  {firstLetterToLower,isFunc} = require('../common'),
   buildValidator = require('./buildValidator');
 
 class ModelEnricher{
@@ -49,7 +49,7 @@ class ModelEnricher{
     mongooseSchema.statics.__incModel = modelName;
     if(options && options.filter){
       mongooseSchema.statics.__incFilter = options.filter;
-    }    
+    }
     return mongooseSchema;
   }
 
@@ -61,7 +61,7 @@ class ModelEnricher{
   static byFieldsValidators (mongooseSchema) {
     if (mongooseSchema) {
       for (let fieldName in mongooseSchema) {
-        if (Object.prototype.hasOwnProperty.call(mongooseSchema[fieldName], 'validate')) {
+        if (Object.prototype.hasOwnProperty.call(mongooseSchema[fieldName], 'validate') && mongooseSchema[fieldName].validate.length && !isFunc(mongooseSchema[fieldName].validate[0])) {
           mongooseSchema[fieldName].validate = buildValidator(mongooseSchema[fieldName].validate);
         }
       }