not-node 4.0.21 → 5.0.1

package/src/manifest/initializator/manifests.js

@@ -0,0 +1,47 @@
+const {notError} = require('not-error');
+const {log,error} = require('not-log')(module, 'initializator');
+const {initManifestFields} = require('../../fields');
+const {firstLetterToUpper} = require('../../common');
+
+module.exports = class notModuleInitializatorManifests{
+  static openFile = require;
+  constructor({nModule}){
+    this.run({nModule});
+  }
+
+  run({nModule}) {
+    const moduleName = nModule.getName();
+    for(let routeName in nModule.getRoutesManifests()) {
+      try{
+        const mod = nModule.getRouteManifest(routeName);
+        if(mod && Array.isArray(mod.fields)){
+          const rawMutationsList = [...mod.fields];
+          const ModelName = firstLetterToUpper(mod.model);
+          const schema = nModule.getModelSchema(ModelName);
+          let privateFields = [];
+          if (mod.privateFields){
+            privateFields = Array.isArray(mod.privateFields)?[...mod.privateFields]:[];
+            delete mod.privateFields;
+          }
+          mod.fields = initManifestFields(
+            nModule.getApp(),
+            schema,
+            rawMutationsList,
+            privateFields,
+            moduleName,
+          );
+        }
+      }catch(e){
+        error(`Error while initialization of route: ${moduleName}//${routeName}`);
+        if(e instanceof notError){
+          error(`name: ${e.options.field}, type: ${e.options.type}`);
+        }else{
+          error(e);
+        }
+      }
+
+    }
+  }
+
+
+};

package/src/manifest/initializator/models.js

@@ -0,0 +1,39 @@
+const {log, error} = require('not-log')(module, 'initializator');
+const protoModel = require('../../model/proto.js');
+const {initFileSchemaFromFields} = require('../../fields');
+const {notError} = require('not-error');
+
+module.exports = class notModuleInitializatorModels{
+  static openFile = require;
+  constructor({nModule}){
+    this.run({nModule, app: nModule.getApp()});
+  }
+
+  run({app, nModule}) {
+    const moduleName = nModule.getName();
+    for(let modelName in nModule.getModels()) {
+      try{
+        initFileSchemaFromFields({
+          app,
+          moduleName: nModule.getName(),
+          mod: nModule.getModelFile(modelName),
+          type: 'model',
+          from: ':FIELDS',
+          to:   ':thisSchema',
+        });
+        protoModel.fabricate(nModule.getModelFile(modelName), nModule.getOptions(), nModule.mongoose);
+        //log(`${moduleName}//${modelName}`);
+      }catch(e){
+        error(`Error while initialization of model: ${moduleName}//${modelName}`);
+        if(e instanceof notError){
+          error(`name: ${e.options.field}, type: ${e.options.type}`);
+        }else{
+          error(e);
+        }
+      }
+
+    }
+  }
+
+
+};

package/src/manifest/module.js

@@ -1,12 +1,13 @@
 //importing modules
-const protoModel = require('../model/proto.js'),
+const
   fs = require('fs'),
   Auth = require('../auth'),
   logger = require('not-log'),
   log = logger(module, 'notModule'),
   notManifest = require('./manifest.js'),
   notModuleRegistrator = require('./registrator'),
-  {objHas, mapBind} = require('../common');
+  notModuleInitializator = require('./initializator'),
+  {objHas, mapBind, isAsync, isFunc} = require('../common');
 
 
 /**
@@ -48,6 +49,8 @@ class notModule {
     this.models = {};
     this.logics = {};
     this.forms = {};
+    this.formsConstructors = {};
+    this.fields = {};
     this.manifests = {};
     this.faulty = false;
     this.paths = {
@@ -56,7 +59,7 @@ class notModule {
     };
     this.fieldsImportRules = (objHas(options, 'fields') && options.fields) ? options.fields : {};
 
-    log.info(`Creating module: ${this.getName()}`);
+  //  log.info(`Creating module: ${this.getName()}`);
     this.init();
     return this;
   }
@@ -81,7 +84,7 @@ class notModule {
     try {
       if (fs.lstatSync(modulePath).isDirectory()) {
         this.module = require(modulePath);
-        notModuleRegistrator.registerContent({nModule: this});
+        this.registerContent();
       }else{
         return false;
       }
@@ -93,13 +96,17 @@ class notModule {
 
   initFromModule() {
     try {
-      notModuleRegistrator.registerContent({nModule: this});
+      this.registerContent();
     } catch (e) {
       this.faulty = true;
       log.error(e);
     }
   }
 
+  registerContent(){
+    notModuleRegistrator.exec({nModule: this});
+  }
+
   getEndPoints() {
     return this.routesWS;
   }
@@ -120,11 +127,15 @@ class notModule {
       root
     );
   }
-  /*
-  getActionManifest({auth, role, root}){
 
+  getRouteManifest(name){
+    return this.manifests[name];
+  }
+
+  getRoutesManifests(){
+    return this.manifests;
   }
-  */
+
   getModelFile(modelName) {
     if (this.models && objHas(this.models, modelName)) {
       return this.models[modelName];
@@ -142,6 +153,10 @@ class notModule {
     }
   }
 
+  getModels(){
+    return this.models;
+  }
+
   getLogicFile(logicName) {
     if (this.logics && objHas(this.logics, logicName)) {
       return this.logics[logicName];
@@ -167,27 +182,16 @@ class notModule {
     return null;
   }
 
-  fabricateModel(model) {
-    protoModel.fabricate(model, this.getOptions(), this.mongoose);
-  }
-
-  fabricateModels() {
-    for (let modelName in this.models) {
-      log.info(`Fabricating model: ${modelName}`);
-      this.fabricateModel(this.models[modelName]);
-    }
-  }
-
-  expose(app, moduleName) {
-    if (this.manifests && app) {
-      this.fabricateModels();
-      this.initManifest(app, moduleName);
+  expose(expressApp, moduleName) {
+    if (this.manifests && expressApp) {
+      notModuleInitializator.exec({nModule: this});
+      this.initManifest(expressApp, moduleName);
       this.manifest.registerRoutes(this.manifests);
     }
   }
 
-  initManifest(app, moduleName){
-    this.manifest = new notManifest(app, this.notApp, moduleName);
+  initManifest(expressApp, moduleName){
+    this.manifest = new notManifest(expressApp, this.notApp, moduleName);
   }
 
   async exec(methodName) {
@@ -195,11 +199,9 @@ class notModule {
       log.error(`Cant exec ${methodName} in module ${this.path}, module not loaded`);
       return false;
     }
-    if ((objHas(this.module, methodName)) &&
-      (typeof this.module[methodName] === 'function')
-    ) {
+    if ((objHas(this.module, methodName)) && (isFunc(this.module[methodName]))) {
       try {
-        if (this.module[methodName].constructor.name === 'AsyncFunction') {
+        if (isAsync(this.module[methodName])) {
           await this.module[methodName](this.notApp);
         } else {
           this.module[methodName](this.notApp);
@@ -283,6 +285,26 @@ class notModule {
     this.forms[key] = val;
   }
 
+  getFormConstructor(key) {
+    return this.formsConstructors[key];
+  }
+
+  setFormConstructor(key, val) {
+    this.formsConstructors[key] = val;
+  }
+
+  getFormsConstructors(){
+    return this.formsConstructors;
+  }
+
+  getField(key) {
+    return this.fields[key];
+  }
+
+  setField(key, val) {
+    this.fields[key] = val;
+  }
+
   setModel(key, val){
     this.models[key] = val;
   }
@@ -303,6 +325,10 @@ class notModule {
     }
   }
 
+  getRoutes(){
+    return this.routes;
+  }
+
   appIsSet(){
     return typeof this.notApp !== 'undefined';
   }

package/src/manifest/registrator/fields.js

@@ -2,6 +2,7 @@ const path = require('path');
 const fs = require('fs');
 const {tryFile, objHas} = require('../../common');
 const Fields = require('../../fields');
+const {log} = require('not-log')(module, 'registrator');
 
 module.exports = class notModuleRegistratorFields{
 
@@ -28,21 +29,21 @@ module.exports = class notModuleRegistratorFields{
     return nModule.module.paths.fields;
   }
 
-
-  registerFields({lib, fieldsImportRules}){
-    notModuleRegistratorFields.fieldsManager.registerFields(
-      lib,  //fields dictionary
-      fieldsImportRules //global import rules
-    );
+  registerFields({ nModule, lib, fromPath}){
+    for(let t in lib){
+      this.registerField({
+        nModule,
+        name: t,
+        field: lib[t],
+        fromPath
+      });
+    }
   }
 
-  registerField({name, field, fieldsImportRules, fromPath}){
+  registerField({nModule, name, field, fromPath}){
     this.extendByFrontValidators({name, field, fromPath});
-    notModuleRegistratorFields.fieldsManager.registerField(
-      name,             //field name
-      field,            //field description
-      fieldsImportRules //global import rules
-    );
+    nModule.setField(name, field);
+    //log(`${nModule.getName()}//${name}`);
   }
 
   /**
@@ -52,7 +53,7 @@ module.exports = class notModuleRegistratorFields{
     if(!(field && objHas(field, 'model'))){ return; }
     //load validators
     const validatorName = path.join(fromPath, 'validators', name + '.js');
-    if(!tryFile(validatorName)){return;}
+    if(!tryFile(validatorName)){ return; }
     const validators = notModuleRegistratorFields.openFile(validatorName);
     //inject into field.model
     if(!objHas(field.model, 'validate')){
@@ -61,7 +62,6 @@ module.exports = class notModuleRegistratorFields{
     field.model.validate.push(...validators);
   }
 
-
   /**
   * Searching fields in directory
   * @param {Object}     input
@@ -80,15 +80,16 @@ module.exports = class notModuleRegistratorFields{
     let fields = notModuleRegistratorFields.openFile(fromPath);
     if (fields && objHas(fields, 'FIELDS')) {//collection
       this.registerFields({
+        nModule,
         lib: fields.FIELDS,  //fields dictionary
-        fieldsImportRules: nModule.fieldsImportRules //global import rules
+        fromPath
       });
     } else {//single file fieldname.js
       const parts = path.parse(fromPath);
       this.registerField({
+        nModule,
         name: parts.name, //fields name
         field: fields,       //field description
-        fieldsImportRules: nModule.fieldsImportRules, //global import rules
         fromPath
       });
     }

package/src/manifest/registrator/forms.js

@@ -5,7 +5,7 @@ const {tryFile} = require('../../common');
 module.exports = class notModuleRegistratorForms{
 
   static openFile = require;
-  
+
   constructor({nModule}){
     this.run({nModule});
   }
@@ -42,7 +42,7 @@ module.exports = class notModuleRegistratorForms{
   register({nModule, fromPath}){
     const Form = notModuleRegistratorForms.openFile(fromPath);
     const parts = path.parse(fromPath);
-    nModule.setForm(parts.name, new Form());
+    nModule.setFormConstructor(parts.name, Form);
   }
 
 };

package/src/manifest/registrator/index.js

@@ -1,3 +1,5 @@
+const BatchRunner = require('../batchRunner.js');
+
 /**
  * Logic to find and register resources of notModule
  * @module notModuleRegistrator
@@ -25,30 +27,4 @@ const DEFAULT_REGISTRATORS = [
  * Search and register notModule resouces
  * @class
  **/
-module.exports  = class notModuleRegistrator{
-
-  static registrators = [...DEFAULT_REGISTRATORS];
-
-  static setRegistrators(list){
-    notModuleRegistrator.registrators = [...list];
-  }
-
-  static resetRegistrators(){
-    notModuleRegistrator.setRegistrators(DEFAULT_REGISTRATORS);
-  }
-
-  /**
-  * Searching for content of module and registering it.
-  * @static
-  * @param {Object}      input
-  * @param {notModule}   input.nModule
-  * @return {boolean}                       true - executed, false - no paths
-  **/
-  static registerContent({nModule}) {
-    if (!nModule.module.paths) {return false;}
-    //starting from simpliest forms and moving upwards
-    notModuleRegistrator.registrators.forEach(registrator => new registrator({nModule}));
-    return true;
-  }
-
-};
+module.exports  = new BatchRunner(DEFAULT_REGISTRATORS);

package/src/manifest/registrator/locales.js

@@ -1,4 +1,4 @@
-const log = require('not-log')(module, 'notModule');
+const log = require('not-log')(module, 'registrator');
 const notLocale = require('not-locale');
 
 module.exports = class notModuleRegistratorLocales{

package/src/manifest/registrator/logics.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const logger = require('not-log');
-const log = logger(module, 'notModule');
+const log = logger(module, 'registrator');
 
 const {tryFile, mapBind} = require('../../common');
 /**
@@ -49,7 +49,7 @@ module.exports = class notModuleRegistratorLogics{
   findAll({nModule,srcDir}){
     fs.readdirSync(srcDir).forEach((file) => {
       let fromPath = path.join(srcDir, file);
-      log.info(`Checking logic in ${fromPath}`);
+      //log.info(`Checking logic in ${fromPath}`);
       if (!tryFile(fromPath)) { return; }
       this.register({nModule, fromPath, file});
     });
@@ -60,7 +60,7 @@ module.exports = class notModuleRegistratorLogics{
     const logicName = notModuleRegistratorLogics.getName({logic, file});
     this.extend({nModule, logic, logicName, fromPath});
     nModule.setLogic(logicName, logic);
-    log.info(`Logic registered: ${logicName}`);
+    //log.info(`${logicName}`);
   }
 
   extend({nModule, logic, logicName, fromPath}) {

package/src/manifest/registrator/models.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const logger = require('not-log');
-const log = logger(module, 'notModule');
+const log = logger(module, 'registrator');
 
 const {tryFile, mapBind} = require('../../common');
 /**
@@ -46,7 +46,7 @@ module.exports = class notModuleRegistratorModels{
   findAll({nModule,srcDir}){
     fs.readdirSync(srcDir).forEach((file) => {
       let fromPath = path.join(srcDir, file);
-      log.info(`Checking model in ${fromPath}`);
+      //log.info(`Checking model in ${fromPath}`);
       if (!tryFile(fromPath)) { return; }
       this.register({nModule, fromPath, file});
     });
@@ -57,7 +57,7 @@ module.exports = class notModuleRegistratorModels{
     const modelName = notModuleRegistratorModels.getName({model, file});
     this.extend({nModule, model, modelName, fromPath});
     nModule.setModel(modelName, model);
-    log.info(`Model registered: ${modelName}`);
+    //log.info(`${modelName}`);
   }
 
   extend({nModule, model, modelName, fromPath}) {

package/src/manifest/registrator/routes.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const logger = require('not-log');
-const log = logger(module, 'notModule');
+const log = logger(module, 'registrator');
 
 const {tryFile, mapBind} = require('../../common');
 

package/src/model/enrich.js

@@ -1,7 +1,7 @@
 /** @module Model/Enrich */
-
-const Schema = require('mongoose').Schema,
-  {firstLetterToLower,isFunc} = require('../common'),
+const
+  Schema = require('mongoose').Schema,
+  {firstLetterToLower,isFunc, objHas} = require('../common'),
   buildValidator = require('./buildValidator');
 
 class ModelEnricher{
@@ -61,7 +61,7 @@ class ModelEnricher{
   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])) {
+        if (objHas(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

@@ -146,7 +146,6 @@ module.exports = class ModelFabricate{
     }
   }
 
-
   static initMongooseModel(targetModule, schema, mongoose){
     if (mongoose.modelNames().indexOf(targetModule.thisModelName)===-1){
       targetModule[targetModule.thisModelName] = mongoose.model(targetModule.thisModelName, schema);

package/test/notApp.js

@@ -13,10 +13,10 @@ describe('noApp', function() {
       let app = new notApp({
         someOption: true
       });
-      expect(app.options).to.deep.equal({
+      expect(app.getOptions()).to.deep.equal({
         someOption: true
       });
-      expect(app.modules).to.deep.equal({});
+      expect(app.getModulesNames()).to.deep.equal([]);
     });
   });