nodefony 7.0.0-beta.2 → 7.0.0-beta.21

package/kernel/fixture.es6

@@ -1,20 +1,17 @@
 class Fixture extends nodefony.Service {
-  constructor(name, container) {
+  constructor (name, container) {
     super(name, container);
     this.orm = this.kernel.getORM();
     this.ormName = this.orm.name;
   }
 
-  async run(...args) {
+  async run (...args) {
     return new Promise((resolve) => {
-      //console.log(...args)
+      // console.log(...args)
       if (this.orm.ready) {
         return resolve(this.initialize.call(this, ...args));
-      } else {
-        this.orm.once("onOrmReady", () => {
-          return resolve(this.initialize.call(this, ...args));
-        });
       }
+      this.orm.once("onOrmReady", () => resolve(this.initialize.call(this, ...args)));
     });
   }
 }

package/kernel/injections/injections.es6

@@ -1,5 +1,5 @@
 // plugin Reader
-const pluginReader = function () {
+const pluginReader = (function () {
   const importXmlConfig = function (file, prefix, callback, parser) {
     if (parser) {
       file = this.render(file, parser.data, parser.options);
@@ -8,20 +8,20 @@ const pluginReader = function () {
     let parameters;
 
     this.xmlParser.parseString(file, (err, node) => {
-      //console.log(require('util').inspect(node, {depth: null}));
-      //console.log('\n\n');
+      // console.log(require('util').inspect(node, {depth: null}));
+      // console.log('\n\n');
       if (err) {
-        this.log("INJECTION xmlParser.parseString : " + err, 'WARNING');
+        this.log(`INJECTION xmlParser.parseString : ${err}`, "WARNING");
       }
       if (!node) {
         return node;
       }
-      for (let key in node) {
+      for (const key in node) {
         switch (key) {
-        case 'parameters':
+        case "parameters":
           parameters = this.xmlToJson.call(this, node[key][0].parameter);
           break;
-        case 'services':
+        case "services":
           services = this.xmlToJson.call(this, node[key][0].service);
           break;
         }
@@ -32,28 +32,28 @@ const pluginReader = function () {
     });
   };
   const nomarlizeXmlJson = function (services, parameters, callback) {
-    for (let key in services) {
-      for (let param in services[key]) {
+    for (const key in services) {
+      for (const param in services[key]) {
         let values = null;
         switch (param) {
-        case 'argument':
+        case "argument":
           values = [];
           for (let elm = 0; elm < services[key][param].length; elm++) {
             if (services[key][param][elm].type && services[key][param][elm].id) {
-              if (services[key][param][elm].type == 'service') {
-                values.push('@' + services[key][param][elm].id);
+              if (services[key][param][elm].type == "service") {
+                values.push(`@${services[key][param][elm].id}`);
               }
             }
           }
-          services[key]['arguments'] = values;
+          services[key].arguments = values;
           delete services[key][param];
           break;
-        case 'property':
+        case "property":
           values = {};
           for (let elm = 0; elm < services[key][param].length; elm++) {
             if (services[key][param][elm].type && services[key][param][elm].id && services[key][param][elm].name) {
-              if (services[key][param][elm].type == 'service') {
-                values[services[key][param][elm].name] = '@' + services[key][param][elm].id;
+              if (services[key][param][elm].type == "service") {
+                values[services[key][param][elm].name] = `@${services[key][param][elm].id}`;
               }
             }
           }
@@ -61,21 +61,21 @@ const pluginReader = function () {
           delete services[key][param];
           break;
 
-        case 'call':
+        case "call":
           values = [];
           for (let elm = 0; elm < services[key][param].length; elm++) {
-            let tab = [];
-            for (let sparam in services[key][param][elm]) {
+            const tab = [];
+            for (const sparam in services[key][param][elm]) {
               switch (sparam) {
-              case 'method':
+              case "method":
                 tab[0] = services[key][param][elm][sparam];
                 break;
-              case 'argument':
-                let args = [];
+              case "argument":
+                const args = [];
                 for (let selem = 0; selem < services[key][param][elm][sparam].length; selem++) {
                   if (services[key][param][elm][sparam][selem].type && services[key][param][elm][sparam][selem].id) {
-                    if (services[key][param][elm][sparam][selem].type == 'service') {
-                      args.push('@' + services[key][param][elm][sparam][selem].id);
+                    if (services[key][param][elm][sparam][selem].type == "service") {
+                      args.push(`@${services[key][param][elm][sparam][selem].id}`);
                     }
                   }
                 }
@@ -88,7 +88,7 @@ const pluginReader = function () {
           services[key].calls = values;
           delete services[key][param];
           break;
-        case 'scope':
+        case "scope":
           break;
         }
       }
@@ -98,19 +98,19 @@ const pluginReader = function () {
     }
   };
   const renderParameters = function (callback, services, parameters) {
-    if (parameters && Object.keys(parameters).length > 0 && typeof (services) === 'object' && Object.keys(services).length > 0) {
+    if (parameters && Object.keys(parameters).length > 0 && typeof services === "object" && Object.keys(services).length > 0) {
       services = JSON.parse(this.render(JSON.stringify(services), parameters));
     }
     callback(services);
   };
   const getServicesXML = function (file, bundle, parser, callback) {
-    importXmlConfig.call(this, file, '', callback, parser);
+    importXmlConfig.call(this, file, "", callback, parser);
   };
   const getServicesJSON = function (file, bundle, parser, callback) {
     if (parser) {
       file = this.render(file, parser.data, parser.options);
     }
-    let json = JSON.parse(file);
+    const json = JSON.parse(file);
     if (callback) {
       renderParameters.call(this, callback, json.services, json.parameters);
     }
@@ -119,7 +119,7 @@ const pluginReader = function () {
     if (parser) {
       file = this.render(file, parser.data, parser.options);
     }
-    let json = yaml.load(file);
+    const json = yaml.load(file);
     if (callback) {
       renderParameters.call(this, callback, json.services, json.parameters);
     }
@@ -135,17 +135,18 @@ const pluginReader = function () {
     xml: getServicesXML,
     json: getServicesJSON,
     yml: getServicesYML,
-    javascript: javascript
+    javascript
   };
-}();
+}());
 
 const regService = new RegExp("^(.+)Service$");
 const reg = /constructor\s*\((.*)\)/;
+
 /**
  * CLASS INJECTOR
  */
 class Injector extends nodefony.Service {
-  constructor(name, service, container) {
+  constructor (name, service, container) {
     super(name, container);
     this.services = nodefony.services;
     try {
@@ -154,12 +155,12 @@ class Injector extends nodefony.Service {
       this.classArgs = Injector.getArguments.call(this.Class);
       this.injections = this.findInjections(service.arguments);
       this.calls = this.getServiceCall(service);
-      this.setParameters("services." + this.name, {
+      this.setParameters(`services.${this.name}`, {
         class: this.Class,
         name: this.name,
         scope: this.container.id,
-        //className: this.className,
-        //orderArguments: false,
+        // className: this.className,
+        // orderArguments: false,
         injections: service.arguments,
         calls: service.calls
       });
@@ -169,7 +170,7 @@ class Injector extends nodefony.Service {
     }
   }
 
-  getServiceClass(service) {
+  getServiceClass (service) {
     let Class = null;
     switch (nodefony.typeOf(service.class)) {
     case "array":
@@ -182,15 +183,15 @@ class Injector extends nodefony.Service {
       Class = this.services[service.class];
       break;
     default:
-      throw new Error("Service Name " + this.className + " bad Class");
+      throw new Error(`Service Name ${this.className} bad Class`);
     }
     if (!Class) {
-      throw new Error("Service Name " + this.className + " class not found");
+      throw new Error(`Service Name ${this.className} class not found`);
     }
     return this.Class = Class;
   }
 
-  getServiceName(Class) {
+  getServiceName (Class) {
     let name = null;
     if (Class) {
       name = Class.name;
@@ -198,7 +199,7 @@ class Injector extends nodefony.Service {
       name = this.Class.name;
     }
     if (name) {
-      let res = regService.exec(name);
+      const res = regService.exec(name);
       if (res) {
         return this.className = res[1];
       }
@@ -207,7 +208,7 @@ class Injector extends nodefony.Service {
     return null;
   }
 
-  getServiceCall(service) {
+  getServiceCall (service) {
     let ele = null;
     if (service.calls) {
       ele = {};
@@ -224,7 +225,7 @@ class Injector extends nodefony.Service {
           args = service.calls[i].arguments;
           break;
         default:
-          this.log(service.calls, 'ERROR');
+          this.log(service.calls, "ERROR");
           throw new Error("Service bad Calls config ");
         }
         ele[method] = this.findInjections(args);
@@ -233,16 +234,16 @@ class Injector extends nodefony.Service {
     return ele;
   }
 
-  startService(restart) {
+  async startService (restart) {
     try {
-      let instance = this.reflect();
+      const instance = await this.reflect();
       this.set(this.name, instance);
       if (this.calls) {
-        for (let call in this.calls) {
+        for (const call in this.calls) {
           if (instance[call]) {
-            this.call(instance, instance[call], this.calls[call]);
+            await this.call(instance, instance[call], this.calls[call]);
           } else {
-            this.log('Method ' + call + ' in service ' + this.name + ' not found', "ERROR");
+            this.log(`Method ${call} in service ${this.name} not found`, "ERROR");
             continue;
           }
         }
@@ -251,7 +252,7 @@ class Injector extends nodefony.Service {
       if (restart) {
         log = "RESTARTED";
       }
-      instance.log(log, 'DEBUG');
+      instance.log(log, "DEBUG");
       return instance;
     } catch (e) {
       this.log(e, "ERROR");
@@ -259,11 +260,11 @@ class Injector extends nodefony.Service {
     }
   }
 
-  async restartService() {
-    this.log("RESTART : " + this.name, "INFO");
+  async restartService () {
+    this.log(`RESTART : ${this.name}`, "INFO");
     try {
       const service = this.get(this.name);
-      if( service && service.close){
+      if (service && service.close) {
         await service.close();
       }
       this.remove(this.name);
@@ -273,35 +274,33 @@ class Injector extends nodefony.Service {
     }
   }
 
-  static getArguments() {
-    let str = this.toString();
+  static getArguments () {
+    const str = this.toString();
     let m = str.match(reg);
     if (m) {
       // case class
-      m = m[1].replace(/\s/g, '');
-      return m.split(',');
-    } else {
-      // case function
-      m = str.match(new RegExp(this.name + "\s*\((.*)\)"));
-      if (m) {
-        m = m[1].replace(/\s/g, '');
-        return m.split(',');
-      } else {
-        throw new Error("Service :" + this.name + " constructor not find");
-      }
+      m = m[1].replace(/\s/g, "");
+      return m.split(",");
     }
+    // case function
+    m = str.match(new RegExp(`${this.name}\s*\((.*)\)`));
+    if (m) {
+      m = m[1].replace(/\s/g, "");
+      return m.split(",");
+    }
+    throw new Error(`Service :${this.name} constructor not find`);
   }
 
-  reflect() {
+  async reflect () {
     try {
-      return Reflect.construct(this.Class, this.injections);
+      return await Reflect.construct(this.Class, this.injections);
     } catch (e) {
-      this.log("ERRROR SERVICE CLASS " + this.name + " " + e.message, "ERROR");
+      this.log(`ERRROR SERVICE CLASS ${this.name} ${e.message}`, "ERROR");
       throw e;
     }
   }
 
-  /*static reflectEs5(Class, args) {
+  /* static reflectEs5(Class, args) {
     try {
       Array.prototype.unshift.call(args, Class);
       return new(Function.prototype.bind.apply(Class, args));
@@ -310,7 +309,7 @@ class Injector extends nodefony.Service {
       throw e;
     }
   }*/
-  call(context, func, args) {
+  call (context, func, args) {
     try {
       func.apply(context, args);
     } catch (e) {
@@ -318,21 +317,21 @@ class Injector extends nodefony.Service {
     }
   }
 
-  findInjections(args) {
-    let tab = [];
+  findInjections (args) {
+    const tab = [];
     if (args instanceof Array) {
       for (let elm = 0; elm < args.length; elm++) {
         switch (nodefony.typeOf(args[elm])) {
         case "string":
           let name = null;
           switch (args[elm][0]) {
-          case '@':
+          case "@":
             name = args[elm].substring(1);
-            let service = this.get(name);
+            const service = this.get(name);
             if (service) {
               tab.push(service);
             } else {
-              this.log("Injection Service  : " + name + " not found !!", "ERROR");
+              this.log(`Injection Service  : ${name} not found !!`, "ERROR");
             }
             break;
           default:
@@ -352,48 +351,43 @@ class Injector extends nodefony.Service {
  *  CLASS INJECTION
  */
 class Injection extends nodefony.Service {
-
-  constructor(container) {
+  constructor (container) {
     super("injection", container, container.get("notificationsCenter"));
     this.injectors = {};
 
-    this.reader = function (context) {
+    this.reader = (function (context) {
       const func = context.get("reader").loadPlugin("injection", pluginReader);
       return function (result, bundle, parser) {
         return func(result, bundle, parser, context.nodeReader.bind(context));
       };
-    }(this);
+    }(this));
   }
 
-  nodeReader(jsonServices) {
-    for (let lib in jsonServices) {
+  async nodeReader (jsonServices) {
+    for (const lib in jsonServices) {
       if (jsonServices[lib].class) {
         if (jsonServices[lib].environment) {
           let inject = false;
-          if (process.env && process.env.NODE_ENV) {
-            if (nodefony.typeOf(jsonServices[lib].environment) === "array") {
-              let res = jsonServices[lib].environment.indexOf(process.env.NODE_ENV);
-              if (res >= 0) {
-                inject = true;
-              }
-              res = jsonServices[lib].environment.indexOf(this.kernel.type);
-              if (res >= 0) {
-                inject = true;
-              }
-            } else {
-              if (jsonServices[lib].environment === process.env.NODE_ENV) {
-                inject = true;
-              }
+          if (nodefony.typeOf(jsonServices[lib].environment) === "array") {
+            let res = jsonServices[lib].environment.indexOf(process.env.NODE_ENV);
+            if (res >= 0) {
+              inject = true;
             }
-            if (!inject) {
-              this.log(`environment : ${process.env.NODE_ENV} BYPASS SERVICE START : ${lib}`, "DEBUG");
-              continue;
+            res = jsonServices[lib].environment.indexOf(this.kernel.type);
+            if (res >= 0) {
+              inject = true;
             }
+          } else if (jsonServices[lib].environment === process.env.NODE_ENV) {
+            inject = true;
+          }
+          if (!inject) {
+            this.log(`environment : ${process.env.NODE_ENV} BYPASS SERVICE START : ${lib}`, "DEBUG");
+            continue;
           }
         }
         try {
-          let injector = this.setInjector(lib, jsonServices[lib]);
-          injector.startService();
+          const injector = this.setInjector(lib, jsonServices[lib]);
+          await injector.startService();
         } catch (e) {
           throw e;
         }
@@ -403,12 +397,12 @@ class Injection extends nodefony.Service {
     }
   }
 
-  setInjector(name, service) {
+  setInjector (name, service) {
     try {
-      let injector = new Injector(name, service, this.container);
+      const injector = new Injector(name, service, this.container);
       if (this.kernel.environment === "dev" && this.kernel.type !== "CONSOLE") {
         if (this.injectors[name]) {
-          this.log("Service name : " + name + " Already exist ", "WARNING");
+          this.log(`Service name : ${name} Already exist `, "WARNING");
         }
         this.injectors[name] = injector;
       }
@@ -418,7 +412,7 @@ class Injection extends nodefony.Service {
     }
   }
 
-  getInjector(name) {
+  getInjector (name) {
     if (this.injectors[name]) {
       return this.injectors[name];
     }