not-node 4.0.16 → 4.0.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "not-node",
-  "version": "4.0.16",
+  "version": "4.0.20",
   "description": "node complimentary part for client side notFramework.",
   "main": "index.js",
   "scripts": {

package/src/common.js

@@ -1,4 +1,5 @@
 const fs = require('fs');
+const path = require('path');
 const notPath = require('not-path');
 
 /** @module Common */
@@ -8,7 +9,7 @@ const notPath = require('not-path');
  * @return {string}        result
  */
 
-module.exports.firstLetterToLower = function (string) {
+module.exports.firstLetterToLower = function(string) {
   return string.charAt(0).toLowerCase() + string.slice(1);
 };
 
@@ -18,7 +19,7 @@ module.exports.firstLetterToLower = function (string) {
  * @return {string}        result
  */
 
-module.exports.firstLetterToUpper = function (string) {
+module.exports.firstLetterToUpper = function(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 };
 
@@ -27,10 +28,10 @@ module.exports.firstLetterToUpper = function (string) {
  *  @param  {string}  id   ObjectId string to validate
  *  @return {booelean}  true if check is not failed
  */
-module.exports.validateObjectId = (id)=>{
-  try{
-    return id.match(/^[0-9a-fA-F]{24}$/)?true:false;
-  }catch(e){
+module.exports.validateObjectId = (id) => {
+  try {
+    return id.match(/^[0-9a-fA-F]{24}$/) ? true : false;
+  } catch (e) {
     return false;
   }
 };
@@ -41,24 +42,24 @@ module.exports.validateObjectId = (id)=>{
  *  @param  {string|ObjectId}  secondId   second id
  *  @return {booelean}        true if equal
  */
-module.exports.compareObjectIds = (firstId, secondId)=>{
-  try{
-    let a = firstId, b = secondId;
-    if(typeof firstId !== 'string'){
+module.exports.compareObjectIds = (firstId, secondId) => {
+  try {
+    let a = firstId,
+      b = secondId;
+    if (typeof firstId !== 'string') {
       a = a.toString();
     }
-    if(typeof secondId !== 'string'){
+    if (typeof secondId !== 'string') {
       b = b.toString();
     }
-    if(
-      !module.exports.validateObjectId(a)
-      ||
+    if (
+      !module.exports.validateObjectId(a) ||
       !module.exports.validateObjectId(b)
-    ){
+    ) {
       return false;
     }
     return a === b;
-  }catch(e){
+  } catch (e) {
     return false;
   }
 };
@@ -67,9 +68,9 @@ module.exports.compareObjectIds = (firstId, secondId)=>{
  *  Returns today Date object without hours, minutes, seconds
  *  @return {number}  current date with 00:00:00 in ms of unix time
  */
-module.exports.getTodayDate = ()=>{
+module.exports.getTodayDate = () => {
   let t = new Date();
-  return (new Date(t.getFullYear(), t.getMonth(),t.getDate())).getTime();
+  return (new Date(t.getFullYear(), t.getMonth(), t.getDate())).getTime();
 };
 
 
@@ -84,22 +85,22 @@ module.exports.objHas = objHas;
 
 
 /**
-* Copies object to secure it from changes
-* @param {object}   obj     original object
-* @return {object}          copy of object
-**/
+ * Copies object to secure it from changes
+ * @param {object}   obj     original object
+ * @return {object}          copy of object
+ **/
 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
-**/
+ * 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)){
+  let partObj = Object.keys(obj).reduce((prev, curr) => {
+    if (list.includes(curr)) {
       prev[curr] = obj[curr];
     }
     return prev;
@@ -109,38 +110,38 @@ module.exports.partCopyObj = (obj, list) => {
 
 
 /**
-* Test argument type to be 'function'
-* @param {any}  func    possible function
-* @return {boolean}     if this is a function
-**/
+ * Test argument type to be 'function'
+ * @param {any}  func    possible function
+ * @return {boolean}     if this is a function
+ **/
 const isFunc = module.exports.isFunc = (func) => {
   return typeof func === 'function';
 };
 
 /**
-* Returns true if argument is Async function
-* @param {function} func  to test
-* @return {boolean}       if this function is constructed as AsyncFunction
-**/
+ * Returns true if argument is Async function
+ * @param {function} func  to test
+ * @return {boolean}       if this function is constructed as AsyncFunction
+ **/
 const isAsync = module.exports.isAsync = (func) => {
   return func.constructor.name === 'AsyncFunction';
 };
 
 
 /**
-*  Executes method of object in appropriate way inside Promise
-* @param {object}   obj     original object
-* @param {string}   name    method name to execute
-* @param {Array}     params  array of params
-* @return {Promise}          results of method execution
-**/
+ *  Executes method of object in appropriate way inside Promise
+ * @param {object}   obj     original object
+ * @param {string}   name    method name to execute
+ * @param {Array}     params  array of params
+ * @return {Promise}          results of method execution
+ **/
 module.exports.executeObjectFunction = async (obj, name, params) => {
-  if (obj){
+  if (obj) {
     const proc = notPath.get(':' + name, obj);
-    if(isFunc(proc)){
-      if(isAsync(proc)){
+    if (isFunc(proc)) {
+      if (isAsync(proc)) {
         return await proc(...params);
-      }else{
+      } else {
         return proc(...params);
       }
     }
@@ -149,14 +150,14 @@ module.exports.executeObjectFunction = async (obj, name, params) => {
 
 
 /**
-*  Executes method of object in apropriate way inside Promise
-* @param {Object}   from     original object
-* @param {Object}   name    method name to execute
-* @param {Array}     list  array of params
-* @return {Promise}          results of method execution
-**/
+ *  Executes method of object in apropriate way inside Promise
+ * @param {Object}   from     original object
+ * @param {Object}   name    method name to execute
+ * @param {Array}     list  array of params
+ * @return {Promise}          results of method execution
+ **/
 module.exports.mapBind = (from, to, list) => {
-  list.forEach((item)=>{
+  list.forEach((item) => {
     if (typeof from[item] === 'function') {
       to[item] = from[item].bind(from);
     }
@@ -165,10 +166,10 @@ module.exports.mapBind = (from, to, list) => {
 
 
 /**
-*  Synchronously check file existence and if it's really a file
-* @param {string}     filePath  full path to file
-* @return {boolean}            true if path exists and it's a file
-**/
+ *  Synchronously check file existence and if it's really a file
+ * @param {string}     filePath  full path to file
+ * @return {boolean}            true if path exists and it's a file
+ **/
 module.exports.tryFile = (filePath) => {
   try {
     const stat = fs.lstatSync(filePath);
@@ -177,3 +178,18 @@ module.exports.tryFile = (filePath) => {
     return false;
   }
 };
+
+/**
+ * Generates paths object for module/index.js files based on content and relative
+ * path
+ * @param {Array<string>}  content  list of module components ['models', 'logics', 'routes',...]
+ * @param {string}         relative  relative path to parent folder of components
+ * @param {Object}         paths object for module/index.js
+ **/
+module.exports.generatePaths = (content = [], relative = 'src') => {
+  const toPath = (name) => path.join(__dirname, relative, name);
+  return content.reduce((prev, cur) => {
+    prev[cur] = toPath(cur);
+    return prev;
+  }, {});
+};

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

@@ -81,11 +81,13 @@ class Form {
         throw e;
       }else {
         throw new notError(
-          'core:form_validation_error', {
+          'core:form_validation_error',
+          {
             FORM_NAME: this.FORM_NAME,
             PROTO_FIELDS: this.PROTO_FIELDS,
             FORM_FIELDS: this.getFields(),
-            data
+            data,
+            message: e.message
           },
           e
         );

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

@@ -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.length && !isFunc(mongooseSchema[fieldName].validate[0])) {
-          mongooseSchema[fieldName].validate = buildValidator(mongooseSchema[fieldName].validate);
+          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/module/fields.js

@@ -24,7 +24,8 @@ module.exports = ({
     describe('run', function() {
       it('path to fields is not defined', function() {
         const ctx = {
-          findAll() {}
+          findAll() {},
+          extendByFrontValidators(){}
         };
         const param = {
           nModule: {
@@ -39,7 +40,8 @@ module.exports = ({
 
       it('paths to fields is defined', function() {
         const ctx = {
-          findAll() {}
+          findAll() {},
+          extendByFrontValidators(){}
         };
         const param = {
           nModule: {
@@ -149,7 +151,9 @@ module.exports = ({
 
     describe('registerField', function() {
       it('file is a single field', () => {
-        const ctx = {};
+        const ctx = {
+          extendByFrontValidators(){}
+      };
         const param = {
           name: 'single',
           field: require(path.resolve(__dirname, '../testies/module/fields/single.js')),

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;
     });
   });