not-node 4.0.15 → 4.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "not-node",
-  "version": "4.0.15",
+  "version": "4.0.19",
   "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/domain.js

@@ -100,7 +100,7 @@ class notDomain extends EventEmitter {
       notApp: this,
       fields: this.options.fields
     });
-    this.importModule(mod, moduleName || mod.getModuleName());
+    this.importModule(mod, moduleName || mod.getName());
     return this;
   }
 
@@ -235,7 +235,7 @@ class notDomain extends EventEmitter {
       return this.modules[moduleName];
     } else {
       for (let t in this.modules) {
-        if (this.modules[t].getModuleName() === moduleName) {
+        if (this.modules[t].getName() === moduleName) {
           return this.modules[t];
         }
       }

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/form.js

@@ -25,15 +25,20 @@ class Form {
     FORM_NAME
   }) {
     this.FORM_NAME = FORM_NAME;
-    this.FIELDS = FIELDS;
-    this.SCHEMA = byFieldsValidators(initFields(FIELDS, 'model'));
+    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
@@ -43,7 +48,7 @@ class Form {
    **/
   async run(req) {
     let data = await this.extract(req);
-    await this.validate(data);
+    await this._validate(data);
     return data;
   }
 
@@ -62,9 +67,9 @@ class Form {
    * @return {Object}
    * @throws {notValidationError}
    **/
-  async validate(data) {
+  async _validate(data) {
     try {
-      await this.MODEL.validate(data, this.FIELDS);
+      await this.validate(data);
     } catch (e) {
       let fields = {};
       if (e instanceof mongoose.Error.ValidationError) {
@@ -72,12 +77,17 @@ class Form {
           fields[name] = [e.errors[name].message];
         });
         throw new notValidationError(e.message, fields, e, data);
-      } else {
+      } else if (e instanceof notValidationError){
+        throw e;
+      }else {
         throw new notError(
-          'core:form_validation_error', {
+          'core:form_validation_error',
+          {
             FORM_NAME: this.FORM_NAME,
-            FIELDS: this.FIELDS,
-            data
+            PROTO_FIELDS: this.PROTO_FIELDS,
+            FORM_FIELDS: this.getFields(),
+            data,
+            message: e.message
           },
           e
         );
@@ -85,6 +95,10 @@ class Form {
     }
   }
 
+  async validate(data){
+    await this.MODEL.validate(data, this.getFields());
+  }
+
   static fabric(){
     return FormFabric;
   }

package/src/manifest/module.js

@@ -56,17 +56,11 @@ class notModule {
     };
     this.fieldsImportRules = (objHas(options, 'fields') && options.fields) ? options.fields : {};
 
-    log.info(`Creating module: ${this.getModuleName()}`);
+    log.info(`Creating module: ${this.getName()}`);
     this.init();
     return this;
   }
 
-  getModuleName() {
-    if(this.module && this.module.name){
-      return this.module.name;
-    }
-    return this.path;
-  }
 
   init() {
     if (this.path) {
@@ -174,7 +168,7 @@ class notModule {
   }
 
   fabricateModel(model) {
-    protoModel.fabricate(model, {}, this.mongoose);
+    protoModel.fabricate(model, this.getOptions(), this.mongoose);
   }
 
   fabricateModels() {
@@ -318,7 +312,14 @@ class notModule {
   }
 
   getName(){
-    return this.module.name;
+    if(this.module && this.module.name){
+      return this.module.name;
+    }
+    return this.path;
+  }
+
+  getOptions(){
+    return (this.module && this.module.options)?this.module.options:{};
   }
 
   setRouteWS({

package/src/manifest/registrator/fields.js

@@ -36,14 +36,30 @@ module.exports = class notModuleRegistratorFields{
     );
   }
 
-  registerField({name, field, fieldsImportRules}){
+  registerField({name, field, fieldsImportRules, fromPath}){
+    this.extendByFrontValidators({name, field, fromPath});
     notModuleRegistratorFields.fieldsManager.registerField(
-      name, //field name
-      field,       //field description
+      name,             //field name
+      field,            //field description
       fieldsImportRules //global import rules
     );
   }
 
+  /**
+  *
+  **/
+  extendByFrontValidators({name, field, fromPath}){
+    if(!(field && objHas(field, 'model'))){ return; }
+    //load validators
+    const validatorName = path.join(fromPath, 'validators', name + '.js');
+    if(!tryFile(validatorName)){return;}
+    const validators = notModuleRegistratorFields.openFile(validatorName);
+    //inject into field.model
+    if(!objHas(field.model, 'validate')){
+      field.model.validate = [];
+    }
+    field.model.validate.push(...validators);
+  }
 
 
   /**
@@ -72,11 +88,10 @@ module.exports = class notModuleRegistratorFields{
       this.registerField({
         name: parts.name, //fields name
         field: fields,       //field description
-        fieldsImportRules: nModule.fieldsImportRules //global import rules
+        fieldsImportRules: nModule.fieldsImportRules, //global import rules
+        fromPath
       });
     }
   }
 
-
-
 };

package/src/model/buildValidator.js

@@ -1,5 +1,44 @@
 /** @module Model/Validator */
 const validate = require('mongoose-validator');
+const {objHas, executeObjectFunction, isFunc} = require('../common');
+
+function extractValidationEnvGetter(options){
+  if(options && objHas(options, 'getValidationEnv') && isFunc(options.getValidationEnv)){
+    return options.getValidationEnv;
+  }else{
+    //should return at least empty object
+    return ()=>{return {};};
+  }
+}
+
+function extendObsolete(rule){
+  const result = {...rule};
+  if(objHas(result, 'arguments') && !Array.isArray(result.arguments)){
+    result.arguments = Object.values(result.arguments);
+  }
+  return validate(result);
+}
+
+function extendModern(rule, options){
+  const result = {...rule};
+  delete result.validator;
+  const validationEnv = extractValidationEnvGetter(options)();
+  result.validator = async (val) => {
+    return await executeObjectFunction(rule, 'validator', [val, validationEnv]);
+  };
+  return result;
+}
+
+
+function extendValidation(rule, options){
+  if(typeof rule.validator === 'string'){
+    //will extend from text description to validatejs lib validation function
+    return extendObsolete(rule);
+  }else{
+    //more complex validation
+    return extendModern(rule, options);
+  }
+}
 
 /**
  *  Take array of validator (https://www.npmjs.com/package/validator) rules
@@ -7,10 +46,8 @@ const validate = require('mongoose-validator');
  *  then return it
  **/
 
-module.exports = function(validators) {
-  var result = null;
-  result = validators.map((item) => {
-    return validate(item);
-  });
+module.exports = function(validators, options) {
+  let result = null;
+  result = validators.map(rule => extendValidation(rule, options));
   return result;
 };

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;
   }
 
@@ -58,11 +58,11 @@ class ModelEnricher{
     return mongooseSchema;
   }
 
-  static byFieldsValidators (mongooseSchema) {
+  static byFieldsValidators (mongooseSchema, options) {
     if (mongooseSchema) {
       for (let fieldName in mongooseSchema) {
-        if (Object.prototype.hasOwnProperty.call(mongooseSchema[fieldName], 'validate')) {
-          mongooseSchema[fieldName].validate = buildValidator(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, options);
         }
       }
     }

package/src/model/proto.js

@@ -59,10 +59,10 @@ module.exports = class ModelFabricate{
     this.extendSchemaFrom(targetModule.thisPost, schema.post.bind(schema));
   }
 
-  static enrichByFields(targetModule){
+  static enrichByFields(targetModule, options){
     if (targetModule.enrich) {
       if (targetModule.enrich.validators) {
-        targetModule.thisSchema = enrich.byFieldsValidators(targetModule.thisSchema, targetModule.thisModelName);
+        targetModule.thisSchema = enrich.byFieldsValidators(targetModule.thisSchema, options);
       }
       if (targetModule.enrich.versioning) {
         targetModule.thisSchema = enrich.byFieldsForVersioning(targetModule.thisSchema, targetModule.thisModelName);
@@ -125,7 +125,7 @@ module.exports = class ModelFabricate{
     if (ModelFabricate.isNotExtendable(targetModule)) {
       return new Schema(targetModule.thisSchema, options.schemaOptions);
     } else {
-      ModelFabricate.enrichByFields(targetModule);
+      ModelFabricate.enrichByFields(targetModule, options);
       //collecting information of unique fields, removing unique flag from schema
       let fieldsForIndexes = ModelFabricate.collectFieldsForIndexes(targetModule);
       //creating schema for model

package/test/notDomain.js

@@ -390,12 +390,12 @@ describe('notDomain', function() {
     it('exists, but with custom name', function() {
       const route = 'Jungle';
       const targetMod = {
-        getModuleName(){ return 'Jungle'; }
+        getName(){ return 'Jungle'; }
       };
       const ctx = {
         modules:{
           loop:{
-            getModuleName(){return 'loop'; }
+            getName(){return 'loop'; }
           },
           trees: targetMod
         }
@@ -408,12 +408,12 @@ describe('notDomain', function() {
     it('not exists', function() {
       const route = 'Jungle';
       const targetMod = {
-        getModuleName(){ return 'Jungle1'; }
+        getName(){ return 'Jungle1'; }
       };
       const ctx = {
         modules:{
           loop:{
-            getModuleName(){return 'loop'; }
+            getName(){return 'loop'; }
           },
           trees: targetMod
         }

package/test/notModule.js

@@ -144,14 +144,14 @@ describe('notModule', function() {
           name: 'fake my name'
         }
       }
-      expect(notModule.prototype.getModuleName.call(ctx)).to.be.equal('fake my name');
+      expect(notModule.prototype.getName.call(ctx)).to.be.equal('fake my name');
     });
 
     it('no module.name, no path', function() {
       const ctx = {
         module: {}
       }
-      expect(notModule.prototype.getModuleName.call(ctx)).to.be.undefined;
+      expect(notModule.prototype.getName.call(ctx)).to.be.undefined;
     });
   });