not-node 5.0.19 → 5.1.0

package/src/manifest/registrator/fields.js

@@ -1,98 +1,103 @@
-const path = require('path');
-const fs = require('fs');
-const {tryFile, objHas} = require('../../common');
-const Fields = require('../../fields');
-const {log} = require('not-log')(module, 'registrator');
+const path = require("path");
+const fs = require("fs");
+const { tryFile, objHas } = require("../../common");
+const Fields = require("../../fields");
 
-module.exports = class notModuleRegistratorFields{
+module.exports = class notModuleRegistratorFields {
+    static openFile = require;
+    static fieldsManager = Fields;
 
-  static openFile = require;
-  static fieldsManager = Fields;
-
-  constructor({nModule}){
-    this.run({nModule});
-  }
-
-  run({nModule}){
-    const srcDir = notModuleRegistratorFields.getPath(nModule);
-    if (!srcDir) { return false; }
-    this.findAll(
-      {
-        nModule,
-        srcDir
-      }
-    );
-    return true;
-  }
+    constructor({ nModule }) {
+        this.run({ nModule });
+    }
 
-  static getPath(nModule){
-    return nModule.module.paths.fields;
-  }
+    run({ nModule }) {
+        const srcDir = notModuleRegistratorFields.getPath(nModule);
+        if (!srcDir) {
+            return false;
+        }
+        this.findAll({
+            nModule,
+            srcDir,
+        });
+        return true;
+    }
 
-  registerFields({ nModule, lib, fromPath}){
-    for(let t in lib){
-      this.registerField({
-        nModule,
-        name: t,
-        field: lib[t],
-        fromPath
-      });
+    static getPath(nModule) {
+        return nModule.module.paths.fields;
     }
-  }
 
-  registerField({nModule, name, field, fromPath}){
-    this.extendByFrontValidators({name, field, fromPath});
-    nModule.setField(name, field);
-    //log(`${nModule.getName()}//${name}`);
-  }
+    registerFields({ nModule, lib, fromPath }) {
+        for (let t in lib) {
+            this.registerField({
+                nModule,
+                name: t,
+                field: lib[t],
+                fromPath,
+            });
+        }
+    }
 
-  /**
-  *
-  **/
-  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 = [];
+    registerField({ nModule, name, field, fromPath }) {
+        this.extendByFrontValidators({ name, field, fromPath });
+        nModule.setField(name, field);
+        //log(`${nModule.getName()}//${name}`);
     }
-    field.model.validate.push(...validators);
-  }
 
-  /**
-  * Searching fields in directory
-  * @param {Object}     input
-  * @param {notModule}  input.notModule
-  * @param {string}     input.srcDir
-  **/
-  findAll({nModule, srcDir}){
-    fs.readdirSync(srcDir).forEach((file) => {
-      let fromPath = path.join(srcDir, file);
-      if (!tryFile(fromPath)) { return; }
-      this.register({nModule, fromPath});
-    });
-  }
+    /**
+     *
+     **/
+    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);
+    }
 
-  register({nModule, fromPath}){
-    let fields = notModuleRegistratorFields.openFile(fromPath);
-    if (fields && objHas(fields, 'FIELDS')) {//collection
-      this.registerFields({
-        nModule,
-        lib: fields.FIELDS,  //fields dictionary
-        fromPath
-      });
-    } else {//single file fieldname.js
-      const parts = path.parse(fromPath);
-      this.registerField({
-        nModule,
-        name: parts.name, //fields name
-        field: fields,       //field description
-        fromPath
-      });
+    /**
+     * Searching fields in directory
+     * @param {Object}     input
+     * @param {notModule}  input.notModule
+     * @param {string}     input.srcDir
+     **/
+    findAll({ nModule, srcDir }) {
+        fs.readdirSync(srcDir).forEach((file) => {
+            let fromPath = path.join(srcDir, file);
+            if (!tryFile(fromPath)) {
+                return;
+            }
+            this.register({ nModule, fromPath });
+        });
     }
-  }
 
+    register({ nModule, fromPath }) {
+        let fields = notModuleRegistratorFields.openFile(fromPath);
+        if (fields && objHas(fields, "FIELDS")) {
+            //collection
+            this.registerFields({
+                nModule,
+                lib: fields.FIELDS, //fields dictionary
+                fromPath,
+            });
+        } else {
+            //single file fieldname.js
+            const parts = path.parse(fromPath);
+            this.registerField({
+                nModule,
+                name: parts.name, //fields name
+                field: fields, //field description
+                fromPath,
+            });
+        }
+    }
 };

package/src/manifest/registrator/forms.js

@@ -1,48 +1,48 @@
-const path = require('path');
-const fs = require('fs');
-const {tryFile} = require('../../common');
-
-module.exports = class notModuleRegistratorForms{
-
-  static openFile = require;
-
-  constructor({nModule}){
-    this.run({nModule});
-  }
-
-  run({nModule}){
-    const srcDir = notModuleRegistratorForms.getPath(nModule);
-    if (!srcDir) { return false; }
-    this.findAll(
-      {
-        nModule,
-        srcDir
-      }
-    );
-    return true;
-  }
-
-  static getPath(nModule){
-    return nModule.module.paths.forms;
-  }
-
-  /**
-  * Searching forms in directory
-  * @param {Object}     input
-  * @param {string}     input.srcDir
-  **/
-  findAll({nModule, srcDir}){
-    fs.readdirSync(srcDir).forEach((file) => {
-      let fromPath = path.join(srcDir, file);
-      if (!tryFile(fromPath)) { return; }
-      this.register({nModule, fromPath});
-    });
-  }
-
-  register({nModule, fromPath}){
-    const Form = notModuleRegistratorForms.openFile(fromPath);
-    const parts = path.parse(fromPath);
-    nModule.setFormConstructor(parts.name, Form);
-  }
-
+const path = require("path");
+const fs = require("fs");
+const { tryFile } = require("../../common");
+
+module.exports = class notModuleRegistratorForms {
+    static openFile = require;
+
+    constructor({ nModule }) {
+        this.run({ nModule });
+    }
+
+    run({ nModule }) {
+        const srcDir = notModuleRegistratorForms.getPath(nModule);
+        if (!srcDir) {
+            return false;
+        }
+        this.findAll({
+            nModule,
+            srcDir,
+        });
+        return true;
+    }
+
+    static getPath(nModule) {
+        return nModule.module.paths.forms;
+    }
+
+    /**
+     * Searching forms in directory
+     * @param {Object}     input
+     * @param {string}     input.srcDir
+     **/
+    findAll({ nModule, srcDir }) {
+        fs.readdirSync(srcDir).forEach((file) => {
+            let fromPath = path.join(srcDir, file);
+            if (!tryFile(fromPath)) {
+                return;
+            }
+            this.register({ nModule, fromPath });
+        });
+    }
+
+    register({ nModule, fromPath }) {
+        const Form = notModuleRegistratorForms.openFile(fromPath);
+        const parts = path.parse(fromPath);
+        nModule.setFormConstructor(parts.name, Form);
+    }
 };

package/src/manifest/registrator/index.js

@@ -1,30 +1,28 @@
-const BatchRunner = require('../batchRunner.js');
+const BatchRunner = require("../batchRunner.js");
 
 /**
  * Logic to find and register resources of notModule
  * @module notModuleRegistrator
  **/
 
-const
-  notModuleRegistratorFields = require('./fields'),
-  notModuleRegistratorForms = require('./forms'),
-  notModuleRegistratorModels = require('./models'),
-  notModuleRegistratorLogics = require('./logics'),
-  notModuleRegistratorRoutes = require('./routes'),
-  notModuleRegistratorLocales = require('./locales');
-
+const notModuleRegistratorFields = require("./fields"),
+    notModuleRegistratorForms = require("./forms"),
+    notModuleRegistratorModels = require("./models"),
+    notModuleRegistratorLogics = require("./logics"),
+    notModuleRegistratorRoutes = require("./routes"),
+    notModuleRegistratorLocales = require("./locales");
 
 const DEFAULT_REGISTRATORS = [
-  notModuleRegistratorFields,
-  notModuleRegistratorForms,
-  notModuleRegistratorModels,
-  notModuleRegistratorLogics,
-  notModuleRegistratorRoutes,
-  notModuleRegistratorLocales
+    notModuleRegistratorFields,
+    notModuleRegistratorForms,
+    notModuleRegistratorModels,
+    notModuleRegistratorLogics,
+    notModuleRegistratorRoutes,
+    notModuleRegistratorLocales,
 ];
 
 /**
  * Search and register notModule resouces
  * @class
  **/
-module.exports  = new BatchRunner(DEFAULT_REGISTRATORS);
+module.exports = new BatchRunner(DEFAULT_REGISTRATORS);

package/src/manifest/registrator/locales.js

@@ -1,20 +1,21 @@
-const log = require('not-log')(module, 'registrator');
-const notLocale = require('not-locale');
+const log = require("not-log")(module, "registrator");
+const notLocale = require("not-locale");
 
-module.exports = class notModuleRegistratorLocales{
-  constructor({nModule}){
-    this.run({nModule});
-  }
+module.exports = class notModuleRegistratorLocales {
+    constructor({ nModule }) {
+        this.run({ nModule });
+    }
 
-  run({nModule}){
-    const srcDir = notModuleRegistratorLocales.getPath(nModule);
-    if (!srcDir) { return false; }
-    notLocale.fromDir(srcDir, nModule.getName()).catch(log.error);
-    return true;
-  }
-
-  static getPath(nModule){
-    return nModule.module.paths.locales;
-  }
+    run({ nModule }) {
+        const srcDir = notModuleRegistratorLocales.getPath(nModule);
+        if (!srcDir) {
+            return false;
+        }
+        notLocale.fromDir(srcDir, nModule.getName()).catch(log.error);
+        return true;
+    }
 
+    static getPath(nModule) {
+        return nModule.module.paths.locales;
+    }
 };

package/src/manifest/registrator/logics.js

@@ -1,83 +1,85 @@
-const fs = require('fs');
-const path = require('path');
-const logger = require('not-log');
-const log = logger(module, 'registrator');
+const fs = require("fs");
+const path = require("path");
+const logger = require("not-log");
 
-const {tryFile, mapBind} = require('../../common');
+const { tryFile, mapBind } = require("../../common");
 /**
  * List of methods to be binded from notApp to logics
  * @constant
  * @type {string}
  **/
 const LOGIC_BINDINGS_LIST = [
-  'getModel', 'getModelFile', 'getModelSchema',
-  'getLogic', 'getLogicFile',
-  'getModule'
+    "getModel",
+    "getModelFile",
+    "getModelSchema",
+    "getLogic",
+    "getLogicFile",
+    "getModule",
 ];
 
-module.exports = class notModuleRegistratorLogics{
-  static openFile = require;
+module.exports = class notModuleRegistratorLogics {
+    static openFile = require;
 
-  constructor({nModule}){
-    this.run({nModule});
-  }
-
-  run({nModule}){
-    const srcDir = notModuleRegistratorLogics.getPath(nModule);
-    if (!srcDir) { return false; }
-    this.findAll(
-      {
-        nModule,
-        srcDir
-      }
-    );
-    return true;
-  }
-
-  static getPath(nModule){
-    return nModule.module.paths.logics;
-  }
+    constructor({ nModule }) {
+        this.run({ nModule });
+    }
 
+    run({ nModule }) {
+        const srcDir = notModuleRegistratorLogics.getPath(nModule);
+        if (!srcDir) {
+            return false;
+        }
+        this.findAll({
+            nModule,
+            srcDir,
+        });
+        return true;
+    }
 
-  /**
-  * Searching fields in directory
-  * @static
-  * @param {Object}     input
-  * @param {notModule}  input.notModule
-  * @param {string}     input.srcDir
-  **/
-  findAll({nModule,srcDir}){
-    fs.readdirSync(srcDir).forEach((file) => {
-      let fromPath = path.join(srcDir, file);
-      //log.info(`Checking logic in ${fromPath}`);
-      if (!tryFile(fromPath)) { return; }
-      this.register({nModule, fromPath, file});
-    });
-  }
+    static getPath(nModule) {
+        return nModule.module.paths.logics;
+    }
 
-  register({nModule, fromPath, file}){
-    const logic = notModuleRegistratorLogics.openFile(fromPath);
-    const logicName = notModuleRegistratorLogics.getName({logic, file});
-    this.extend({nModule, logic, logicName, fromPath});
-    nModule.setLogic(logicName, logic);
-    //log.info(`${logicName}`);
-  }
+    /**
+     * Searching fields in directory
+     * @static
+     * @param {Object}     input
+     * @param {notModule}  input.notModule
+     * @param {string}     input.srcDir
+     **/
+    findAll({ nModule, srcDir }) {
+        fs.readdirSync(srcDir).forEach((file) => {
+            let fromPath = path.join(srcDir, file);
+            //log.info(`Checking logic in ${fromPath}`);
+            if (!tryFile(fromPath)) {
+                return;
+            }
+            this.register({ nModule, fromPath, file });
+        });
+    }
 
-  extend({nModule, logic, logicName, fromPath}) {
-    logic.filename = fromPath;
-    if (nModule.appIsSet()) {
-      mapBind(nModule.getApp(), logic, LOGIC_BINDINGS_LIST);
+    register({ nModule, fromPath, file }) {
+        const logic = notModuleRegistratorLogics.openFile(fromPath);
+        const logicName = notModuleRegistratorLogics.getName({ logic, file });
+        this.extend({ nModule, logic, logicName, fromPath });
+        nModule.setLogic(logicName, logic);
+        //log.info(`${logicName}`);
     }
-    logic.log = logger(logic, `Logic#${logicName}`);
-    logic.getThisModule = () => nModule;
-  }
 
-  static getName({logic, file}){
-    let logicName = file;
-    if (logic && logic.thisLogicName) {
-      logicName = logic.thisLogicName;
+    extend({ nModule, logic, logicName, fromPath }) {
+        logic.filename = fromPath;
+        if (nModule.appIsSet()) {
+            mapBind(nModule.getApp(), logic, LOGIC_BINDINGS_LIST);
+        }
+        logic.log = logger(logic, `Logic#${logicName}`);
+        logic.getThisModule = () => nModule;
     }
-    return logicName;
-  }
 
+    static getName({ logic, file }) {
+        let logicName = file;
+        if (logic && logic.thisLogicName) {
+            logicName = logic.thisLogicName;
+        }
+        return logicName;
+    }
 };

package/src/manifest/registrator/models.js

@@ -1,80 +1,82 @@
-const fs = require('fs');
-const path = require('path');
-const logger = require('not-log');
-const log = logger(module, 'registrator');
+const fs = require("fs");
+const path = require("path");
+const logger = require("not-log");
 
-const {tryFile, mapBind} = require('../../common');
+const { tryFile, mapBind } = require("../../common");
 /**
  * List of methods to be binded from notApp to models
  * @constant
  * @type {string}
  **/
 const MODEL_BINDINGS_LIST = [
-  'getModel', 'getModelFile', 'getModelSchema',
-  'getModule'
+    "getModel",
+    "getModelFile",
+    "getModelSchema",
+    "getModule",
 ];
 
-module.exports = class notModuleRegistratorModels{
-  static openFile = require;
-  constructor({nModule}){
-    this.run({nModule});
-  }
-
-  run({nModule}){
-    const srcDir = notModuleRegistratorModels.getPath(nModule);
-    if (!srcDir) { return false; }
-    this.findAll(
-      {
-        nModule,
-        srcDir
-      }
-    );
-    return true;
-  }
+module.exports = class notModuleRegistratorModels {
+    static openFile = require;
+    constructor({ nModule }) {
+        this.run({ nModule });
+    }
 
-  static getPath(nModule){
-    return nModule.module.paths.models;
-  }
+    run({ nModule }) {
+        const srcDir = notModuleRegistratorModels.getPath(nModule);
+        if (!srcDir) {
+            return false;
+        }
+        this.findAll({
+            nModule,
+            srcDir,
+        });
+        return true;
+    }
 
-  /**
-  * Searching fields in directory
-  * @static
-  * @param {Object}     input
-  * @param {notModule}  input.notModule
-  * @param {string}     input.srcDir
-  **/
-  findAll({nModule,srcDir}){
-    fs.readdirSync(srcDir).forEach((file) => {
-      let fromPath = path.join(srcDir, file);
-      //log.info(`Checking model in ${fromPath}`);
-      if (!tryFile(fromPath)) { return; }
-      this.register({nModule, fromPath, file});
-    });
-  }
+    static getPath(nModule) {
+        return nModule.module.paths.models;
+    }
 
-  register({nModule, fromPath, file}){
-    const model = notModuleRegistratorModels.openFile(fromPath);
-    const modelName = notModuleRegistratorModels.getName({model, file});
-    this.extend({nModule, model, modelName, fromPath});
-    nModule.setModel(modelName, model);
-    //log.info(`${modelName}`);
-  }
+    /**
+     * Searching fields in directory
+     * @static
+     * @param {Object}     input
+     * @param {notModule}  input.notModule
+     * @param {string}     input.srcDir
+     **/
+    findAll({ nModule, srcDir }) {
+        fs.readdirSync(srcDir).forEach((file) => {
+            let fromPath = path.join(srcDir, file);
+            //log.info(`Checking model in ${fromPath}`);
+            if (!tryFile(fromPath)) {
+                return;
+            }
+            this.register({ nModule, fromPath, file });
+        });
+    }
 
-  extend({nModule, model, modelName, fromPath}) {
-    model.filename = fromPath;
-    if (nModule.appIsSet()) {
-      mapBind(nModule.getApp(), model, MODEL_BINDINGS_LIST);
+    register({ nModule, fromPath, file }) {
+        const model = notModuleRegistratorModels.openFile(fromPath);
+        const modelName = notModuleRegistratorModels.getName({ model, file });
+        this.extend({ nModule, model, modelName, fromPath });
+        nModule.setModel(modelName, model);
+        //log.info(`${modelName}`);
     }
-    model.log = logger(model, `Model#${modelName}`);
-    model.getThisModule = () => nModule;
-  }
 
-  static getName({model, file}){
-    let modelName = file;
-    if (model && model.thisModelName) {
-      modelName = model.thisModelName;
+    extend({ nModule, model, modelName, fromPath }) {
+        model.filename = fromPath;
+        if (nModule.appIsSet()) {
+            mapBind(nModule.getApp(), model, MODEL_BINDINGS_LIST);
+        }
+        model.log = logger(model, `Model#${modelName}`);
+        model.getThisModule = () => nModule;
     }
-    return modelName;
-  }
 
+    static getName({ model, file }) {
+        let modelName = file;
+        if (model && model.thisModelName) {
+            modelName = model.thisModelName;
+        }
+        return modelName;
+    }
 };