not-node 4.0.21 → 5.0.3

package/src/fields/index.js

@@ -1,142 +1,156 @@
 const clone = require('rfdc')();
-const fs = require('fs');
-const path = require('path');
-const {objHas, tryFile} = require('../common');
+const notPath = require('not-path');
+const {error} = require('not-log')(module, 'init//fields');
+const {notError} = require('not-error');
 
-const DEFAULT_FIELD_REGISTRATION_RULES = {
-  overwrite: false,
-  compose: true
-};
-
-const FIELDS = {};
+const {
+  objHas,
+} = require('../common');
 
+const DEFAULT_TYPE = 'ui';
+const DEFAULT_FROM = ':FIELDS';
+const DEFAULT_TO = ':thisSchema';
 
-module.exports.importFromDir = (srcDir, {overwrite = false, compose = true} = DEFAULT_FIELD_REGISTRATION_RULES)=>{
-  fs.readdirSync(srcDir).forEach((file) => {
-    let fromPath = path.join(srcDir, file);
-    if (!tryFile(fromPath)) { return; }
-    const parts = path.parse(fromPath);
-    registerField(parts.name, require(fromPath), {overwrite, compose});
-  });
-};
-
-const registerField = module.exports.registerField = (name, value, {overwrite = false, compose = true} = DEFAULT_FIELD_REGISTRATION_RULES)=>{
-  if(objHas(FIELDS, name)){
-    if(overwrite){
-      FIELDS[name] = value;
-    }else if(compose){
-      Object.assign(FIELDS[name], value);
-    }
-  }else{
-    FIELDS[name] = value;
-  }
-};
-
-module.exports.registerFields = (fields, {overwrite = false, compose = true})=>{
-  for(let t in fields){
-    module.exports.registerField(t, fields[t], {overwrite, compose});
+module.exports.initFileSchemaFromFields = ({app, mod, type = DEFAULT_TYPE, from = DEFAULT_FROM, to = DEFAULT_TO, moduleName = ''})=>{
+  const FIELDS = notPath.get(from, mod);
+  if(FIELDS && Array.isArray(FIELDS)){
+    const schema = module.exports.createSchemaFromFields(app, FIELDS, type, moduleName);
+    notPath.set(to, mod, schema);
   }
 };
 
 /**
-list = [
+fields = [
   'title', //for standart only name
   ['titleNonStandart', {component: 'UITextforBlind'}] //arrays of [name, mutation]
   ['someID', {}, 'ID'],  //copy of standart ID field under name as someID
 ]
-*/
-module.exports.initFields = (list, type = 'ui') => {
-  let fields = {};
-  list.forEach((field) => {
-    let res = module.exports.initField(field, false, type);
-    fields[res[0]] = res[1];
+**/
+module.exports.createSchemaFromFields = (app, fields, type = 'ui', moduleName) => {
+  let schema = {};
+  fields.forEach((field) => {
+    let [schemaFieldName, schemaFieldValue] = module.exports.initSchemaField(app, field, false, type, moduleName);
+    schema[schemaFieldName] = schemaFieldValue;
   });
-  return fields;
+  return schema;
 };
 
 
+module.exports.initSchemaField = (app, field, resultOnly = true, type = 'ui', moduleName) => {
+  //log(field);
+  let {
+    srcName,
+    destName,
+    mutation
+  } = parseFieldDescription(field);
+  let proto = findFieldPrototype(app, srcName, type);
+  if(!proto){
+    error(`field ${moduleName}//${destName} prototype ${srcName} of ${type} type is not found`);
+  }
+  let schemaFieldValue = Object.assign({}, clone(proto), mutation);
+  if (resultOnly) {
+    return schemaFieldValue;
+  } else {
+    return [destName, schemaFieldValue];
+  }
+};
+
 /**
-* Retrieves field information
-* there are few signatures of this function
-* (field:string, resultOnly:boolean = true, type:string = 'ui')=> Object | [string, Object]
-* (field:Array<string, Object>, resultOnly:boolean = true, type:string = 'ui')=> Object | [string, Object]
-* @param {(string|Array)} field   field to retrieve from store and init
-                                  field: string - just name of the field
-                                  field: Array - [destinationField:string, mutation: Object, sourceField:string]
-                                  field: Array - [sourceField:string, mutation: Object]
-                                                sourceField - standart field to extend
-                                                mutation - to extend by
-                                                destinationField - name of resulting field,
-                                                if no dest then src will be used
-* @param {boolean}  resultOnly    return only result, if false then returns [name, value]
-* @param {string}   type          type of field information
+* field form
+* 'destFieldNameSameAsSourceFieldName' - form 1
+* ['destFieldName', {full: true, field: 'content'}] - form 2
+* ['destFieldName', 'srcFieldName'] //field alias, form 3
+* ['destFieldName', {mutation: 'content'}, 'srcFieldName']// - form 4
 **/
-module.exports.initField = (field, resultOnly = true, type = 'ui') => {
-  let srcName, destName, mutation = {};
+const parseFieldDescription = (field) => {
+  let srcName,
+    destName,
+    mutation = {};
   if (Array.isArray(field)) {
     destName = srcName = field[0];
-    mutation = field[1];
-    if (field.length === 3) {
+    if(field.length === 2){
+      if(typeof field[1] === 'string'){
+        srcName = field[1]; //form 3
+      }else{
+        mutation = field[1]; //form 2
+      }
+    }else if (field.length === 3) { //form 4
+      mutation = field[1];
       srcName = field[2];
     }
   } else {
-    destName = srcName = field;
-  }
-  let proto = (objHas(FIELDS, srcName) && objHas(FIELDS[srcName], type)) ? FIELDS[srcName][type]:{};
-  let result = Object.assign({}, clone(proto), mutation);
-  if (resultOnly) {
-    return result;
-  } else {
-    return [destName, result];
+    destName = srcName = field; //form 1
   }
+  return {
+    srcName,
+    destName,
+    mutation
+  };
 };
 
-/**
-* Returns mutation tuple for a field or false
-* @param {string} name  field name
-* @param {Array} list  fields description lists
-* @return {boolean|item}
-*/
-function getMutationForField(name, list) {
-  for(let item of list){
-    if (Array.isArray(item) && item[0] === name) {
-      return item;
-    }
+const findFieldPrototype = (app, name, type) => {
+  const fieldPrototype = app.getField(name);
+  if(fieldPrototype && objHas(fieldPrototype, type)){
+    return fieldPrototype[type];
+  }else{
+    return null;
   }
-  return false;
-}
-module.exports.getMutationForField = getMutationForField;
+};
 
 /**
-* Takes in mongoose model schema, scans for fields names nad creates list of
-* field's names to initialize from LIB, if in supplied rawMutationsList, exists
-* mutation for a field in list, field name in list will be replaced by a
-* mutation description
-* @param {Object} schema            mongoose model schema
-* @param {Array}  rawMutationsList  list of mutations [src, mutation]/[dst,mutation,src]
-* @returns {Object}                 initialized ui descriptions of fields for schema
+* Creates fields UI representation schema from list of fields in DB model
+* and library of fields
+* @param {object} app     notApplication instance
+* @param {object} schema  model db schema
+* @param {Array<string|Array>} rawMutationsList     fields mutations, for little tuning
+* @param {Array<string>} privateFields     fields to omit from result
+* @param {string} moduleName     for detailed reports on issues, in which module and what field is faulty
+* @returns {object}       resulting UI rendering schema for fields
 **/
-module.exports.fromSchema = (schema, rawMutationsList = []) => {
+
+module.exports.initManifestFields = (
+  app,                    //notApplication
+  schema,                 //schema of model
+  rawMutationsList = [],  //fields mutations
+  privateFields = [],     //fields to omit
+  moduleName              //module name for reporting
+) => {
   let
     //shallow copy of array
     mutationsList = [...rawMutationsList],
     list = [];
   if (schema && Object.keys(schema).length > 0) {
     let rawKeys = Object.keys(schema);
-    rawKeys.forEach((key) => {
-      let mutation = getMutationForField(key, mutationsList);
-      if (mutation) {
-        list.push(mutation);
-        mutationsList.splice(mutationsList.indexOf(mutation), 1);
-      } else {
-        list.push(key);
-      }
-    });
+    rawKeys
+      .filter((key) => !privateFields.includes(key))
+      .forEach((key) => {
+        let mutation = getMutationForField(key, mutationsList);
+        if (mutation) {
+          list.push(mutation);
+          mutationsList.splice(mutationsList.indexOf(mutation), 1);
+        } else {
+          list.push(key);
+        }
+      });
     list.push(...mutationsList);
-    return module.exports.initFields(list);
+    return module.exports.createSchemaFromFields(app, list, 'ui', moduleName);
   }else{
     return {};
   }
 };
 
-module.exports.LIB = FIELDS;
+/**
+* Returns mutation tuple for a field or false
+* @param {string} name  field name
+* @param {Array} list  fields description lists
+* @return {boolean|item}
+*/
+function getMutationForField(name, list) {
+  for(let item of list){
+    if (Array.isArray(item) && item[0] === name) {
+      return item;
+    }
+  }
+  return false;
+}
+module.exports.getMutationForField = getMutationForField;

package/src/form/form.js

@@ -1,15 +1,18 @@
-//DB related validation tools
-const mongoose = require('mongoose');
-const Schema = mongoose.Schema;
-//not-node
-const initFields = require('../fields').initFields;
-
 const FormFabric = require('./fabric');
 
+const {
+  createSchemaFromFields
+} = require('../fields');
+
 const {
   byFieldsValidators
 } = require('../model/enrich');
 
+const {objHas} = require('../common');
+
+const ValidationBuilder = require('not-validation').Builder;
+const ValidationSession = require('not-validation').Session;
+
 const {
   notValidationError,
   notError
@@ -20,23 +23,29 @@ const {
  * Generic form validation class
  **/
 class Form {
+  /**
+  * @prop {SCHEMA} validation schema
+  **/
+  #SCHEMA = {
+    fields: {},
+    form: []
+  };
+  /**
+  * @prop {string} name of form
+  **/
+  #FORM_NAME;
+  #PROTO_FIELDS;
+  #VALIDATOR;
+
   constructor({
     FIELDS,
-    FORM_NAME
+    FORM_NAME,
+    app
   }) {
-    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);
+    this.#FORM_NAME = FORM_NAME;
+    this.#PROTO_FIELDS = FIELDS;
+    this.#createValidationSchema(app);
+    this.#augmentValidationSchema();
   }
 
   /**
@@ -48,7 +57,7 @@ class Form {
    **/
   async run(req) {
     let data = await this.extract(req);
-    await this._validate(data);
+    await this.#_validate(data);
     return data;
   }
 
@@ -61,30 +70,128 @@ class Form {
     return {};
   }
 
+  /**
+  * Runs all validation rules against data
+  * Collects all errors to an object
+  * if validation failes - returns error object with detail per field description
+  * of errors
+  * @param {object} data input data for validation
+  * @returns {Promise<void>} resolves or throwing notValidationError or notError if reason is unknown
+  **/
+  async validate(data){
+    try{
+      const validationResult = await ValidationSession(this.#SCHEMA, data);
+      if(!validationResult.clean){
+        throw new notValidationError('not-core:form_validation_error', validationResult.getReport(), null, data);
+      }
+    }catch(e){
+      if (e instanceof notValidationError){
+        throw e;
+      }else {
+        throw new notError('not-core:form_validation_unknown_error', {
+          FORM_NAME: this.#FORM_NAME,
+          PROTO_FIELDS: this.#PROTO_FIELDS,
+          FORM_FIELDS: this.getFields(),
+          message: e.message
+        }, e);
+      }
+    }
+  }
+
+  //should be overriden
+  /**
+  * Returns form specified rules of validation
+  **/
+  getFormValidationRules(){
+    return [];
+  }
+
+  /**
+  * Returns function that works as a getter for additional environment variables for
+  * validators.
+  * validationFunction(value, additionalEnvVars = {}){}
+  **/
+  getValidatorEnvGetter(){
+    return ()=>{ //should be sync function
+      return {
+        env: true //some env variables for validators
+      };
+    };
+  }
+
+  /**
+  * Sets validation rules for field
+  * @param {string} fieldName field name
+  * @param {Array<Object>} validators  validation objects {validator: string|function, message: string}
+  **/
+  setValidatorsForField(fieldName, validators){
+    this.#SCHEMA.fields[fieldName] = validators;
+  }
+
+  /**
+  * Returns array of validators
+  * @return {Arrays<Object>}
+  **/
+  getValidatorsForField(fieldName){
+    return this.#SCHEMA.fields[fieldName];
+  }
+
+  /**
+  * Returns list of field names
+  * @return {Array<string>}
+  **/
+  getFields(){
+    return Object.keys(this.#SCHEMA.fields);
+  }
+
+
+  #createValidationSchema(app){
+    //creating full model schema
+    const modelSchema = this.#createModelSchema(app);
+    //extract fields validation rules
+    this.#extractValidationSchemaFromModelSchema(modelSchema);
+    //now form fields and form validation rules is formed in raw form
+  }
+
+  #createModelSchema(app){
+    return byFieldsValidators(
+      createSchemaFromFields(app, this.#PROTO_FIELDS, 'model', this.#FORM_NAME)
+    );
+  }
+
+
+  #extractValidationSchemaFromModelSchema(modelSchema){
+    for(let t in modelSchema){
+      if (objHas(modelSchema[t], 'validate')){
+        this.setValidatorsForField(t, modelSchema[t].validate);
+      }
+    }
+    this.#SCHEMA.form = this.getFormValidationRules();
+  }
+
+  #augmentValidationSchema(app){
+    this.#SCHEMA = ValidationBuilder(this.#SCHEMA, this.getValidatorEnvGetter());
+  }
+
+
   /**
    * Validates form data or throws
    * @param {Object} data    form data
    * @return {Object}
    * @throws {notValidationError}
    **/
-  async _validate(data) {
+  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){
+      if ((e instanceof notError) || (e instanceof notValidationError)){
         throw e;
       }else {
         throw new notError(
           'core:form_validation_error',
           {
-            FORM_NAME: this.FORM_NAME,
-            PROTO_FIELDS: this.PROTO_FIELDS,
+            FORM_NAME: this.#FORM_NAME,
+            PROTO_FIELDS: this.#PROTO_FIELDS,
             FORM_FIELDS: this.getFields(),
             data,
             message: e.message
@@ -95,10 +202,6 @@ class Form {
     }
   }
 
-  async validate(data){
-    await this.MODEL.validate(data, this.getFields());
-  }
-
   static fabric(){
     return FormFabric;
   }

package/src/init/app.js

@@ -11,7 +11,7 @@ const emit = require('./additional').run;
 
 module.exports = class InitApp{
   static AppConstructor = notAppConstructor;
-  static ReporterConstructor = notErrorReporter
+  static ReporterConstructor = notErrorReporter;
 
   static async createApp({config, options, master}){
     await emit('app.create.pre', {config, options, master});
@@ -32,6 +32,12 @@ module.exports = class InitApp{
     await emit('app.setEnv.post', {config, options, master});
   }
 
+  static async initCore({config, options, master}){
+    await emit('app.initCore.pre', {config, options, master});
+    master.getApp().importModuleFrom(path.join(__dirname, '../core'));
+    await emit('app.initCore.post', {config, options, master});
+  }
+
   static async importModules({config, options, master}){
     await emit('app.importModules.pre', {config, options, master});
     master.getApp().importModulesFrom(config.get('modulesPath'));
@@ -62,6 +68,7 @@ module.exports = class InitApp{
       await emit('app.pre', {config, options, master});
       await InitApp.createApp({config, options, master});
       await InitApp.setAppEnvs({config, options, master});
+      await InitApp.initCore({config, options, master});
       await InitApp.importModules({config, options, master});
       await InitApp.createReporter({config, options, master});
       await emit('app.post', {config, options, master});

package/src/init/db/ioredis.js

@@ -10,7 +10,6 @@ module.exports = class InitDBRedisIO{
     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}){

package/src/init/index.js

@@ -108,7 +108,7 @@ class Init {
   static printOutManifest = () => {
     log.debug('Manifest:');
     log.debug(JSON.stringify(Init.notApp.getManifest(), null, 4));
-  }
+  };
 
   /**
    * Initalization of Application
@@ -127,7 +127,7 @@ class Init {
     additional
   }) {
     try {
-      log.info('Kick start app...'+ os.platform()+os.arch());
+      log.info('Kick start app...'+ os.platform()+' '+os.arch());
       ADDS.init(additional);
       const initSequence = new InitSequence(STANDART_INIT_SEQUENCE);
       await ADDS.run('pre', {
@@ -153,7 +153,8 @@ class Init {
       await ADDS.run('post', {
         config,
         options,
-        manifest
+        manifest,
+        master: Init
       });
       log.info('Application initalization finished');
     } catch (e) {

package/src/init/layers/fields.js

@@ -0,0 +1,7 @@
+module.exports = class InitFields{
+  async run({master/*, config*/}){
+    //compress output
+    const compression = require('compression');
+    master.getServer().use(compression());
+  }
+};

package/src/init/sequence.standart.js

@@ -11,7 +11,7 @@ const initNotApp = require('./app');
 const initSessions = require('./sessions');
 const initTemplate = require('./template');
 const initCORS = require('./cors');
-const initCore = require('./core');
+//const initCore = require('./core');
 const initMiddleware = require('./middleware');
 const initStatic = require('./static');
 const initRoutes = require('./routes');
@@ -25,8 +25,6 @@ module.exports = [
   //creating set of variables derived from basic ones,
   //such as various paths, server names and URIs
   initEnv,
-  //init various resources like common object fields descriptions and locales
-  initCore,
   //DB access drivers
   initDB,
   //http(s) server
@@ -41,6 +39,8 @@ module.exports = [
   initMethodOverride,
   //not-node core
   initNotApp,
+  //init various resources like common object fields descriptions and locales
+  //initCore,
   //user sessions
   initSessions,
   //template engine

package/src/manifest/batchRunner.js

@@ -0,0 +1,33 @@
+/**
+ * Search and register notModule resouces
+ * @class
+ **/
+module.exports  = class BatchRunner{
+  #processors = [];
+  constructor(processors){
+    this.setProcessors(processors);
+  }
+
+  setProcessors(list = []){
+    this.#processors = [...list];
+  }
+
+  resetProcessors(){
+    this.setProcessors();
+  }
+
+  /**
+  * Searching for content of module and registering it.
+  * @static
+  * @param {Object}      input
+  * @param {notModule}   input.nModule
+  * @return {boolean}                       true - executed, false - no paths
+  **/
+  exec({nModule}) {
+    if (!nModule.module.paths) {return false;}
+    //starting from simpliest forms and moving upwards
+    this.#processors.forEach(processor => new processor({nModule}));
+    return true;
+  }
+
+};

package/src/manifest/initializator/forms.js

@@ -0,0 +1,30 @@
+const {notError} = require('not-error');
+const {log, error} = require('not-log')(module, 'initializator');
+
+module.exports = class notModuleInitializatorForms{
+
+  static openFile = require;
+
+  constructor({nModule}){
+    this.run({nModule, app: nModule.getApp()});
+  }
+
+  run({app, nModule}){
+    const moduleName = nModule.getName();
+    for (let formName in nModule.getFormsConstructors()) {
+      try{
+        const formConstructor = nModule.getFormConstructor(formName);
+        nModule.setForm(formName, new formConstructor({app}));
+        //log(`${moduleName}//${formName}`);
+      }catch(e){
+        error(`Error while initialization of form: ${moduleName}//${formName}`);
+        if(e instanceof notError){
+          error(`name: ${e.options.field}, type: ${e.options.type}`);
+        }else{
+          error(e);
+        }
+      }
+    }
+  }
+
+};

package/src/manifest/initializator/index.js

@@ -0,0 +1,24 @@
+const BatchRunner = require('../batchRunner.js');
+
+/**
+ * Logic to find and register resources of notModule
+ * @module notModuleRegistrator
+ **/
+
+const
+  notModuleInitializatorForms = require('./forms'),
+  notModuleInitializatorModels = require('./models'),
+  notModuleInitializatorManifests = require('./manifests');
+
+
+const DEFAULT_INITIALIZATORS = [
+  notModuleInitializatorForms,
+  notModuleInitializatorModels,
+  notModuleInitializatorManifests
+];
+
+/**
+ * Initialize registered notModule resouces
+ * @class
+ **/
+module.exports  = new BatchRunner(DEFAULT_INITIALIZATORS);