not-node 4.0.21 → 5.0.3

package/src/domain.js

@@ -5,7 +5,7 @@
  */
 const EventEmitter = require('events');
 const {isFunc,isAsync, objHas, firstLetterToUpper} = require('./common');
-
+const {error} = require('not-log')(module, 'domain');
 const Env = require('./env');
 const
   notModule = require('./manifest/module'),
@@ -41,32 +41,38 @@ const OPT_DEFAULT_SHUTDOWN_TIMEOUT = 5000;
  **/
 class notDomain extends EventEmitter {
   static OPT_DEFAULT_SHUTDOWN_TIMEOUT = OPT_DEFAULT_SHUTDOWN_TIMEOUT;
+  //named array of notModules wrappers for notModule format modules
+  #modules = {};
+  #options = {};
+
+  #logger = null;
+  #reporter = null;
+  #informer = null;
+  //named ws servers
+  #wss = {};
+  //named ws clients
+  #wsc = {};
+
   constructor(options) {
     super();
-    this.options = options;
-    //named array of notModules wrappers for notModule format modules
-    this.modules = {};
-    this._logger = null;
-    this._reporter = null;
-    this._informer = null;
-    //named ws servers
-    this._wss = {};
-    //named ws clients
-    this._wsc = {};
-    //store
-    this.envs = {};
+    this.#options = options;
+
     return this;
   }
 
+  getOptions(){
+    return this.#options;
+  }
+
   /**
    *  Cycles throu all imported modules, passes name, module, and itself
    *  to argument function
    *  @param   {function}  func  function to perfom some action with module
    **/
   forEachMod(func){
-    if (this.modules) {
-      for (let t of Object.keys(this.modules)) {
-        let mod = this.modules[t];
+    if (this.#modules) {
+      for (let t of Object.keys(this.#modules)) {
+        let mod = this.#modules[t];
         if (mod) {
           func(t, mod, this);
         }
@@ -96,9 +102,9 @@ class notDomain extends EventEmitter {
     let mod = new notModule({
       modPath: modulePath,
       modObject: null,
-      mongoose: this.options.mongoose,
+      mongoose: this.#options.mongoose,
       notApp: this,
-      fields: this.options.fields
+      fields: this.#options.fields
     });
     this.importModule(mod, moduleName || mod.getName());
     return this;
@@ -111,7 +117,7 @@ class notDomain extends EventEmitter {
    *  @return {object}        notDomain
    **/
   importModule(mod, moduleName) {
-    this.modules[moduleName] = mod;
+    this.#modules[moduleName] = mod;
     return this;
   }
 
@@ -123,8 +129,8 @@ class notDomain extends EventEmitter {
   getRoute(name) {
     if (name.indexOf('//') > 0) {
       let [moduleName, routeName, routeFunctionName] = name.split('//');
-      if (this.modules && objHas(this.modules, moduleName)) {
-        let route = this.modules[moduleName].getRoute(routeName);
+      if (this.#modules && objHas(this.#modules, moduleName)) {
+        let route = this.#modules[moduleName].getRoute(routeName);
         if (objHas(route, routeFunctionName)) {
           return route[routeFunctionName];
         }
@@ -144,6 +150,17 @@ class notDomain extends EventEmitter {
     return this.getByPath(name, type);
   }
 
+  /**
+   *  Returns field description
+   *  @param   {string}  name   'fieldName' or 'moduleName//fieldName'
+   *                  ('username', 'not-user//username')
+   *  @return {object}        field
+   **/
+  getField(name) {
+    const type = 'field';
+    return this.getByPath(name, type);
+  }
+
   /**
    *  Returns model
    *  @param   {string}  name   'modelName' or 'moduleName//modelName'
@@ -157,20 +174,22 @@ class notDomain extends EventEmitter {
 
   getByFullPath(name, type){
     let [moduleName, resourceName] = name.split('//');
-    if (this.modules && objHas(this.modules, moduleName)) {
-      return this.modules[moduleName][`get${firstLetterToUpper(type)}`](resourceName);
+    if (this.#modules && objHas(this.#modules, moduleName)) {
+      return this.#modules[moduleName][`get${firstLetterToUpper(type)}`](resourceName);
     } else {
+      error(`resource not found ${type}:${name}`);
       return null;
     }
   }
 
   getByShortPath(resourceName, type){
-    for (let moduleName of Object.keys(this.modules)) {
-      const res = this.modules[moduleName][`get${firstLetterToUpper(type)}`](resourceName);
+    for (let moduleName of Object.keys(this.#modules)) {
+      const res = this.#modules[moduleName][`get${firstLetterToUpper(type)}`](resourceName);
       if(res){
         return res;
       }
     }
+    error(`resource not found ${type}:${resourceName}`);
     return null;
   }
 
@@ -231,12 +250,12 @@ class notDomain extends EventEmitter {
    *  @return {object}  module
    **/
   getModule(moduleName) {
-    if (this.modules && objHas(this.modules,moduleName)) {
-      return this.modules[moduleName];
+    if (this.#modules && objHas(this.#modules,moduleName)) {
+      return this.#modules[moduleName];
     } else {
-      for (let t in this.modules) {
-        if (this.modules[t].getName() === moduleName) {
-          return this.modules[t];
+      for (let t in this.#modules) {
+        if (this.#modules[t].getName() === moduleName) {
+          return this.#modules[t];
         }
       }
       return null;
@@ -248,7 +267,7 @@ class notDomain extends EventEmitter {
    *  @param {string}  methodName  name of the method to execute
    **/
   async execInModules(methodName) {
-    for (let mod of Object.values(this.modules)) {
+    for (let mod of Object.values(this.#modules)) {
       try{
         if(isFunc(mod.exec)){
           if(isAsync(mod.exec)){
@@ -268,7 +287,7 @@ class notDomain extends EventEmitter {
    *  Create mongoose models.
    **/
   fabricate() {
-    for (let mod of Object.values(this.modules)) {
+    for (let mod of Object.values(this.#modules)) {
       mod.fabricateModels && mod.fabricateModels();
     }
   }
@@ -277,12 +296,12 @@ class notDomain extends EventEmitter {
    *  logger
    */
   set logger(logger) {
-    this._logger = logger;
+    this.#logger = logger;
   }
 
   get logger() {
-    if (typeof this._logger !== 'undefined' && this._logger !== null) {
-      return this._logger;
+    if (typeof this.#logger !== 'undefined' && this.#logger !== null) {
+      return this.#logger;
     } else {
       return console;
     }
@@ -306,11 +325,11 @@ class notDomain extends EventEmitter {
   }
 
   set reporter(reporter) {
-    this._reporter = reporter;
+    this.#reporter = reporter;
   }
 
   get reporter() {
-    return this._reporter || this.DEFAULT_REPORTER;
+    return this.#reporter || this.DEFAULT_REPORTER;
   }
 
   report(err) {
@@ -327,11 +346,11 @@ class notDomain extends EventEmitter {
   }
 
   set informer(informer /* not-informer.Informer */ ) {
-    this._informer = informer;
+    this.#informer = informer;
   }
 
   get informer() {
-    return this._informer || this.DEFAULT_INFORMER;
+    return this.#informer || this.DEFAULT_INFORMER;
   }
 
   inform(data /* look for not-informer.Informer.now */ ) {
@@ -339,24 +358,24 @@ class notDomain extends EventEmitter {
   }
 
   addWSServer(name, wss) {
-    this._wss[name] = wss;
+    this.#wss[name] = wss;
   }
 
   WSServer(name = 'main') {
-    if (objHas(this._wss, name)) {
-      return this._wss[name];
+    if (objHas(this.#wss, name)) {
+      return this.#wss[name];
     } else {
       return undefined;
     }
   }
 
   addWSClient(name, wsc) {
-    this._wsc[name] = wsc;
+    this.#wsc[name] = wsc;
   }
 
   WSClient(name) {
-    if (objHas(this._wsc, name)) {
-      return this._wsc[name];
+    if (objHas(this.#wsc, name)) {
+      return this.#wsc[name];
     } else {
       return undefined;
     }
@@ -387,7 +406,7 @@ class notDomain extends EventEmitter {
   * @return {Object}  complex object with results
   **/
   getStatus() {
-    const mods = Object.keys(this.modules);
+    const mods = Object.keys(this.#modules);
     let stats = {
       modules: {
         count: mods.length,
@@ -415,8 +434,8 @@ class notDomain extends EventEmitter {
         list: []
       },
     };
-    for (let modName in this.modules) {
-      const mod = this.modules[modName];
+    for (let modName in this.#modules) {
+      const mod = this.#modules[modName];
       let modStatus = mod.getStatus();
       stats.modules.content[modName] = modStatus;
       stats.routes.count += modStatus.routes.count;
@@ -445,6 +464,10 @@ class notDomain extends EventEmitter {
     return this;
   }
 
+  getModulesNames(){
+    return Object.keys(this.#modules);
+  }
+
 }
 
 module.exports = notDomain;

package/src/fields/.old.js

@@ -0,0 +1,193 @@
+const clone = require('rfdc')();
+const fs = require('fs');
+const path = require('path');
+const {objHas, tryFile} = require('../common');
+
+const DEFAULT_FIELD_REGISTRATION_RULES = {
+  overwrite: false,
+  compose: true
+};
+
+const FIELDS = {};
+
+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});
+  }
+};
+
+/**
+list = [
+  '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];
+  });
+  return fields;
+};
+
+
+/**
+* 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
+**/
+module.exports.initField = (field, resultOnly = true, type = 'ui') => {
+  let srcName, destName, mutation = {};
+  if (Array.isArray(field)) {
+    destName = srcName = field[0];
+    mutation = field[1];
+    if (field.length === 3) {
+      srcName = field[2];
+    }
+  } else {
+    destName = srcName = field;
+  }
+  let proto = findFieldDescription(srcName, type);
+  let result = Object.assign({}, clone(proto), mutation);
+  if (resultOnly) {
+    return result;
+  } else {
+    return [destName, result];
+  }
+};
+
+function findFieldDescription(name, type){
+  return (objHas(FIELDS, name) && objHas(FIELDS[name], type)) ? FIELDS[name][type]:{};
+}
+
+
+
+/**
+* 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;
+
+/**
+* Takes in mongoose model schema, scans for fields names and 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
+**/
+module.exports.fromSchema = (schema, rawMutationsList = []) => {
+  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);
+      }
+    });
+    list.push(...mutationsList);
+    return module.exports.initFields(list);
+  }else{
+    return {};
+  }
+};
+
+module.exports.LIB = FIELDS;
+
+
+module.exports.initFieldsFromApp = (list, type = 'ui', app) => {
+  let fields = {};
+  list.forEach((field) => {
+    let res = module.exports.initFieldFromApp(field, false, type, app);
+    fields[res[0]] = res[1];
+  });
+  return fields;
+};
+
+
+module.exports.initFieldFromApp = (field, resultOnly = true, type = 'ui', app) => {
+  let srcName, destName, mutation = {};
+  if (Array.isArray(field)) {
+    destName = srcName = field[0];
+    mutation = field[1];
+    if (field.length === 3) {
+      srcName = field[2];
+    }
+  } else {
+    destName = srcName = field;
+  }
+  let proto = findFieldDescriptionFromApp(srcName, type, app);
+  if(proto){
+    let result = Object.assign({}, clone(proto), mutation);
+    if (resultOnly) {
+      return result;
+    } else {
+      return [destName, result];
+    }
+  }else{
+    throw new Error(`Field (${srcName}) definition is not found`);
+  }
+};
+
+function findFieldDescriptionFromApp(name, type, app){
+  const field = app.getField(name);
+  if(field && objHas(field, type)){
+    return field[type];
+  }else{
+    return null;
+  }
+}