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

package/kernel/kernel.es6

@@ -1,13 +1,13 @@
-'use strict';
-const os = require('os');
+"use strict";
+const os = require("os");
 const Module = require("module");
 let myrequire = null;
 let mypackage = null;
 
-const makeRequireFunction = function makeRequireFunction(mod) {
+const makeRequireFunction = function makeRequireFunction (mod) {
   const myModule = mod.constructor;
 
-  function myRequire(path) {
+  function myRequire (path) {
     try {
       exports.requireDepth += 1;
       return mod.require(path);
@@ -16,35 +16,35 @@ const makeRequireFunction = function makeRequireFunction(mod) {
     }
   }
 
-  function resolve(request, options) {
-    if (typeof request !== 'string') {
-      throw new new Error(`resolve arg must be a string  ERR_INVALID_ARG_TYPE : ${request}`);
+  function resolve (request, options) {
+    if (typeof request !== "string") {
+      throw new new Error(`resolve arg must be a string  ERR_INVALID_ARG_TYPE : ${request}`)();
     }
     return myModule._resolveFilename(request, mod, false, options);
   }
   myRequire.resolve = resolve;
 
-  function paths(request) {
-    if (typeof request !== 'string') {
-      throw new new Error(`paths arg must be a string  ERR_INVALID_ARG_TYPE : ${request}`);
+  function paths (request) {
+    if (typeof request !== "string") {
+      throw new new Error(`paths arg must be a string  ERR_INVALID_ARG_TYPE : ${request}`)();
     }
     return myModule._resolveLookupPaths(request, mod, true);
   }
   resolve.paths = paths;
-  myRequire.main = module; //process.mainModule;
+  myRequire.main = module; // process.mainModule;
   // Enable support to add extra extension types.
   myRequire.extensions = myModule._extensions;
   myRequire.cache = myModule._cache;
   return myRequire;
 };
-const createRequireFromPath = function createRequireFromPath(filename) {
+const createRequireFromPath = function createRequireFromPath (filename) {
   const m = new Module(filename, module);
   m.filename = filename;
   m.paths = Module._nodeModulePaths(path.dirname(filename));
   return makeRequireFunction(m);
 };
 try {
-  let filemame = path.resolve(process.cwd(), "package.json");
+  const filemame = path.resolve(process.cwd(), "package.json");
   myrequire = createRequireFromPath(filemame);
   mypackage = myrequire(filemame);
 } catch (e) {}
@@ -54,7 +54,7 @@ const regBundle = /^(\w+)[Bb]undle.js$/;
 const regClassBundle = /^(\w+)[Bb]undle$/;
 const regPackageFile = /^\s*file:(.*)/;
 
-/*const promiseBundleReady = function () {
+/* const promiseBundleReady = function () {
   let myresolve = null;
   let myPromise = new Promise((resolve) => {
     myresolve = resolve;
@@ -93,7 +93,8 @@ const defaultOptions = {
   }
 };
 
-const colorLogEvent = clc.cyan.bgBlue(`EVENT KERNEL`);
+const colorLogEvent = clc.cyan.bgBlue("EVENT KERNEL");
+
 /**
  *  KERKEL class
  *  The class is a **`KERNEL NODEFONY`** .
@@ -107,18 +108,20 @@ const colorLogEvent = clc.cyan.bgBlue(`EVENT KERNEL`);
  *
  */
 class Kernel extends nodefony.Service {
-
-  constructor(environment, cli, options) {
+  constructor (environment, cli, options) {
     super("KERNEL", cli.container, cli.notificationsCenter, nodefony.extend({}, defaultOptions, options));
     this.cli = cli;
     this.type = cli.type;
     this.package = mypackage;
-    this.debug = (!!cli.commander.opts().debug) || false;
+    this.debug = Boolean(cli.commander.opts().debug) || false;
+    this.appEnvironment = {
+      environment: process.env.NODE_ENV
+    };
     this.setEnv(environment);
     // Manage Kernel Container
     this.set("kernel", this);
     this.set("cli", this.cli);
-    //Autoloader
+    // Autoloader
     this.autoLoader = nodefony.autoloader;
     this.autoLoader.setKernel(this);
     this.set("autoLoader", this.autoLoader);
@@ -128,7 +131,7 @@ class Kernel extends nodefony.Service {
     this.isElectron = nodefony.isElectron;
     this.uptime = new Date().getTime();
     this.numberCpu = os.cpus().length;
-    //boolean
+    // boolean
     this.console = this.isConsole();
     this.booted = false;
     this.ready = false;
@@ -150,7 +153,7 @@ class Kernel extends nodefony.Service {
     this.path = this.rootDir;
     this.bundlesPath = path.resolve(this.rootDir, "src", "bundles");
     this.appPath = nodefony.appPath; // path.resolve(this.rootDir, "app");
-    this.configPath = nodefony.kernelConfigPath; //path.resolve(this.rootDir, "config", "config.yml");
+    this.configPath = nodefony.kernelConfigPath; // path.resolve(this.rootDir, "config", "config.yml");
     this.generateConfigPath = path.resolve(this.rootDir, "config", "generatedConfig.yml");
     this.publicPath = path.resolve(this.rootDir, "web");
     this.nodefonyPath = this.autoLoader.dirname;
@@ -173,20 +176,20 @@ class Kernel extends nodefony.Service {
       this.git = this.cli.setGitPath(this.rootDir);
       this.once("onPostReady", () => {
         if (process.getuid && process.getuid() === 0) {
-          //this.drop_root();
+          // this.drop_root();
         }
-        //this.clean();
+        // this.clean();
         this.postReady = true;
         switch (this.environment) {
-          case 'production':
-          case 'prod':
-          case 'preprod':
-          case 'preproduction':
-            this.clean();
-            break;
-          default:
-            this.clean();
-            myrequire = null;
+        case "production":
+        case "prod":
+        case "preprod":
+        case "preproduction":
+          this.clean();
+          break;
+        default:
+          this.clean();
+          myrequire = null;
         }
       });
     } catch (e) {
@@ -195,7 +198,7 @@ class Kernel extends nodefony.Service {
     }
   }
 
-  clean() {
+  clean () {
     require.cache = null;
     delete require.cache;
     myrequire.cache = null;
@@ -203,23 +206,23 @@ class Kernel extends nodefony.Service {
     myrequire = null;
   }
 
-  drop_root() {
+  drop_root () {
     try {
-      process.setgid('nobody');
-      process.setuid('nobody');
+      process.setgid("nobody");
+      process.setuid("nobody");
     } catch (e) {
       console.error(e);
-      console.log('Refusing to keep the process alive as root.');
+      console.log("Refusing to keep the process alive as root.");
       nodefony.cli.quit(1);
     }
   }
 
-  getLocalExternalIP() {
+  getLocalExternalIP () {
     return [].concat(...Object.values(os.networkInterfaces()))
       .find((details) => !details.internal);
   }
 
-  getNetworkInterfaces() {
+  getNetworkInterfaces () {
     const nets = os.networkInterfaces();
     const devices = Object.create(null); // or just '{}', an empty object
     for (const name of Object.keys(nets)) {
@@ -235,7 +238,7 @@ class Kernel extends nodefony.Service {
     return devices;
   }
 
-  start() {
+  start () {
     if (!this.started) {
       return this.cli.showAsciify(this.projectName)
         .then(async () => {
@@ -244,28 +247,27 @@ class Kernel extends nodefony.Service {
           try {
             // config
             this.readKernelConfig();
+            this.setNodeEnv(this.environment);
             // Clusters
             this.initCluster();
             // Manage Template engine
             this.initTemplate();
           } catch (e) {
-            console.error(e);
             throw e;
           }
           this.started = true;
           return await this.boot()
-            .catch(e => {
+            .catch((e) => {
               throw e;
             });
         })
-        .catch((e) => {
-          //this.log(e, "ERROR");
+        .catch(async (e) => {
           throw e;
         });
     }
   }
 
-  loadCommand() {
+  loadCommand () {
     try {
       return this.cli.loadCommand()
         .then((commands) => {
@@ -277,30 +279,29 @@ class Kernel extends nodefony.Service {
     } catch (e) {
       this.log(e, "ERROR");
       this.terminate(e.code || 1);
-      return;
     }
   }
 
-  displayCommand(commands) {
-    let table = this.cli.displayTable([], {
+  displayCommand (commands) {
+    const table = this.cli.displayTable([], {
       head: [
         "BUNDLES",
         "COMMAND NAME"
       ]
     });
-    for (let bundle in commands) {
-      let cmd = commands[bundle];
-      for (let command in cmd) {
-        let tab = [];
+    for (const bundle in commands) {
+      const cmd = commands[bundle];
+      for (const command in cmd) {
+        const tab = [];
         tab.push(bundle);
         tab.push(command);
         table.push(tab);
       }
     }
-    this.log("\n" + table.toString(), "DEBUG");
+    this.log(`\n${table.toString()}`, "DEBUG");
   }
 
-  async matchCommand() {
+  async matchCommand () {
     try {
       return await this.cli.matchCommand();
     } catch (e) {
@@ -308,26 +309,26 @@ class Kernel extends nodefony.Service {
     }
   }
 
-  setCli() {
+  setCli () {
     if (this.typeCluster === "worker") {
       this.cli.setPid();
     }
     this.cli.setProcessTitle(this.projectName);
     this.cli.setCommandVersion(this.isCore ? this.version : nodefony.projectVersion);
-    //this.cli.syslog.removeAllListeners();
+    // this.cli.syslog.removeAllListeners();
     this.cli.syslog.reset();
   }
 
-  isBundleCore(name) {
+  isBundleCore (name) {
     if (name in bundlesCore) {
       return true;
     }
-    for (let bundle in bundlesCore) {
+    for (const bundle in bundlesCore) {
       if (bundlesCore[bundle] === name) {
         return true;
       }
     }
-    let res = regBundleName.exec(name);
+    const res = regBundleName.exec(name);
     if (res) {
       if (res[2]) {
         return this.isBundleCore(res[2].toLowerCase());
@@ -336,11 +337,10 @@ class Kernel extends nodefony.Service {
     return false;
   }
 
-
-  getRegisteredBundles(name = null) {
-    if( name){
+  getRegisteredBundles (name = null) {
+    if (name) {
       const bundle = this.getBundle(name);
-      if( bundle){
+      if (bundle) {
         return {
           name: bundle.name,
           packageName: bundle.package.name,
@@ -352,11 +352,11 @@ class Kernel extends nodefony.Service {
       }
       return null;
     }
-    let tab = [];
+    const tab = [];
     const bundles = this.getBundles();
     for (const mybundle in bundles) {
       const bundle = bundles[mybundle];
-      let ob = {
+      const ob = {
         name: bundle.name,
         packageName: bundle.package.name,
         package: bundle.package,
@@ -369,7 +369,7 @@ class Kernel extends nodefony.Service {
     return tab;
   }
 
-  async getUnregistredBundle(nameBundle) {
+  async getUnregistredBundle (nameBundle) {
     const finder = new nodefony.Finder2({
       recurse: false,
       depth: 1
@@ -394,7 +394,7 @@ class Kernel extends nodefony.Service {
         }
         return null;
       })
-      .catch(e => {
+      .catch((e) => {
         this.log(e, "ERROR");
       });
     if (result.length) {
@@ -406,7 +406,7 @@ class Kernel extends nodefony.Service {
       .in(localNodefony)
       .then((result) => {
         if (result[0].children.length) {
-          //console.log(result[0].children)
+          // console.log(result[0].children)
           return result[0].children
             .map((bundle) => {
               const name = this.regBundleName.exec(bundle.name);
@@ -423,31 +423,36 @@ class Kernel extends nodefony.Service {
         }
         return null;
       })
-      .catch(e => {
+      .catch((e) => {
         this.log(e, "ERROR");
       });
-    if (result.length) {
+    if (result && result.length) {
       return result[0];
     }
     return null;
   }
 
-  loadBundleUnregister(name, bundle) {
-    const mypackage = path.resolve(bundle.path, "package.json");
-    const pack = require(mypackage);
-    return {
-      name: name, //pack.name.replace("@nodefony/", "").replace("-bundle", "").replace("Bundle", ""),
-      packageName: pack.name,
-      package: pack,
-      path: bundle.path,
-      version: pack.version,
-      registred: false
-    };
+  loadBundleUnregister (name, bundle) {
+    try {
+      const mypackage = path.resolve(bundle.path, "package.json");
+      const pack = require(mypackage);
+      return {
+        name, // pack.name.replace("@nodefony/", "").replace("-bundle", "").replace("Bundle", ""),
+        packageName: pack.name,
+        package: pack,
+        path: bundle.path,
+        version: pack.version,
+        registred: false
+      };
+    } catch (e) {
+      this.log(e, "WARNING");
+      return false;
+    }
   }
 
-  async getUnregistredBundles() {
+  async getUnregistredBundles () {
     let tab = [];
-    //unregistered
+    // unregistered
     const finder = new nodefony.Finder2({
       recurse: false,
       depth: 1
@@ -459,7 +464,7 @@ class Kernel extends nodefony.Service {
           return result[0].children
             .map((bundle) => {
               const name = this.regBundleName.exec(bundle.name);
-              if (!(name[1] in this.bundles)) {
+              if (name && !(name[1] in this.bundles)) {
                 return this.loadBundleUnregister(name[1], bundle);
               }
               return false;
@@ -471,17 +476,22 @@ class Kernel extends nodefony.Service {
             });
         }
       })
-      .catch(e => {
+      .catch((e) => {
         this.log(e, "ERROR");
       });
     tab = tab.concat(result);
 
-    const localNodefony = path.resolve(this.nodefonyPath, "bundles");
+    let localNodefony = null;
+    if (this.isCore) {
+      localNodefony = path.resolve(this.nodefonyPath, "bundles");
+    } else {
+      localNodefony = path.resolve(this.path, "node_modules", "@nodefony");
+    }
     result = await finder
       .in(localNodefony)
       .then((result) => {
         if (result[0].children.length) {
-          //console.log(result[0].children)
+          // console.log(result[0].children)
           return result[0].children
             .map((bundle) => {
               const name = this.regBundleName.exec(bundle.name);
@@ -498,40 +508,62 @@ class Kernel extends nodefony.Service {
             });
         }
       })
-      .catch(e => {
+      .catch((e) => {
         this.log(e, "ERROR");
       });
-    tab = tab.concat(result);
+    if (result) {
+      tab = tab.concat(result);
+    }
     return tab;
   }
 
-  setEnv(environment) {
+  setEnv (environment) {
     if (environment in defaultEnvEnable) {
       switch (environment) {
-        case "dev":
-        case "development":
-          this.environment = "dev";
-          process.env.NODE_ENV = "development";
-          process.env.BABEL_ENV = 'development';
-          break;
-        default:
-          this.environment = "prod";
-          process.env.NODE_ENV = "production";
-          process.env.BABEL_ENV = 'production';
+      case "dev":
+      case "development":
+        this.environment = "dev";
+        if (!this.appEnvironment.environment) {
+          this.appEnvironment.environment = "development";
+        }
+        break;
+      default:
+        this.environment = "prod";
+        if (!this.appEnvironment.environment) {
+          this.appEnvironment.environment = "production";
+        }
+      }
+    }
+  }
+
+  setNodeEnv (environment) {
+    if (environment in defaultEnvEnable) {
+      switch (environment) {
+      case "dev":
+      case "development":
+        process.env.NODE_ENV = "development";
+        process.env.BABEL_ENV = "development";
+        break;
+      default:
+        process.env.NODE_ENV = "production";
+        process.env.BABEL_ENV = "production";
       }
     }
     process.env.NODE_DEBUG = this.debug;
   }
 
-  logEnv() {
-    let txt = this.cli.clc.blue("      \x1b KERNEL " + this.type);
-    txt += " Cluster : " + this.cli.clc.magenta(this.typeCluster);
-    txt += " Environment : " + this.cli.clc.magenta(this.environment);
-    txt += " Debug :" + this.cli.clc.magenta(this.debug) + "\n";
+  logEnv () {
+    let txt = `      \x1b ${this.cli.clc.blue(this.type)} `;
+    txt += ` ${this.cli.clc.magenta("Cluster")} : ${this.typeCluster} `;
+    txt += ` ${this.cli.clc.magenta("Nodefony Environment")} : ${this.environment}  `;
+    if (this.appEnvironment) {
+      txt += ` ${this.cli.clc.magenta("App Environment")} : ${this.appEnvironment.environment}  `;
+    }
+    txt += ` ${this.cli.clc.magenta("Debug")} : ${this.debug}\n`;
     return txt;
   }
 
-  readKernelConfig() {
+  readKernelConfig () {
     try {
       if (path.basename(this.configPath) === "config.js") {
         this.settings = this.autoLoader.load(this.configPath, true);
@@ -543,19 +575,19 @@ class Kernel extends nodefony.Service {
       this.settings.environment = this.environment;
       this.settings.debug = this.debug;
       this.setParameters("kernel", this.settings);
-      this.httpPort = nodefony.kernelConfig.system.httpPort || null;
-      this.httpsPort = nodefony.kernelConfig.system.httpsPort || null;
-      this.domain = nodefony.kernelConfig.system.domain || null;
-      this.hostname = nodefony.kernelConfig.system.domain || null;
-      this.hostHttp = this.hostname + ":" + this.httpPort;
-      this.hostHttps = this.hostname + ":" + this.httpsPort;
-      this.domainAlias = nodefony.kernelConfig.system.domainAlias;
-      this.domainCheck = nodefony.kernelConfig.system.domainCheck;
+      this.httpPort = this.settings.system.httpPort || null;
+      this.httpsPort = this.settings.system.httpsPort || null;
+      this.domain = this.settings.system.domain || null;
+      this.hostname = this.settings.system.domain || null;
+      this.hostHttp = `${this.hostname}:${this.httpPort}`;
+      this.hostHttps = `${this.hostname}:${this.httpsPort}`;
+      this.domainAlias = this.settings.system.domainAlias;
+      this.domainCheck = this.settings.system.domainCheck;
       this.initializeLog();
       if (!this.settings.system.bundles) {
         this.settings.system.bundles = {};
       }
-      let gconf = this.readGeneratedConfig();
+      const gconf = this.readGeneratedConfig();
       if (gconf) {
         if (gconf.system && gconf.system.bundles) {
           this.settings = nodefony.extend(true, gconf, this.settings);
@@ -567,22 +599,21 @@ class Kernel extends nodefony.Service {
     }
   }
 
-  checkPath(myPath) {
+  checkPath (myPath) {
     if (!myPath) {
       return null;
     }
-    let abs = path.isAbsolute(myPath);
+    const abs = path.isAbsolute(myPath);
     if (abs) {
       return myPath;
-    } else {
-      return path.resolve(this.rootDir, myPath);
     }
+    return path.resolve(this.rootDir, myPath);
   }
 
-  getConfigBunbles() {
-    let config = [];
+  getConfigBunbles () {
+    const config = [];
     if (this.settings && this.settings.system && this.settings.system.bundles) {
-      for (let bundle in this.settings.system.bundles) {
+      for (const bundle in this.settings.system.bundles) {
         let res = null;
         try {
           res = this.searchPackage(bundle, this.settings.system.bundles[bundle]);
@@ -596,9 +627,9 @@ class Kernel extends nodefony.Service {
     return config;
   }
 
-  checkBundlesExist(yml, nameConfig, pathConfig, remove) {
+  checkBundlesExist (yml, nameConfig, pathConfig, remove) {
     if (yml && yml.system && yml.system.bundles) {
-      for (let bundle in yml.system.bundles) {
+      for (const bundle in yml.system.bundles) {
         let exist = null;
         try {
           exist = this.searchPackage(bundle, yml.system.bundles[bundle]);
@@ -610,27 +641,27 @@ class Kernel extends nodefony.Service {
           if (remove) {
             try {
               fs.writeFileSync(pathConfig, yaml.dump(yml), {
-                encoding: 'utf8'
+                encoding: "utf8"
               });
-              this.log(nameConfig + " : " + bundle + " Bundle don't exist in file : " + pathConfig, "WARNING");
-              this.log("Update Config  : " + pathConfig);
+              this.log(`${nameConfig} : ${bundle} Bundle don't exist in file : ${pathConfig}`, "WARNING");
+              this.log(`Update Config  : ${pathConfig}`);
             } catch (e) {
               this.log(e, "ERROR");
             }
           } else {
-            let error = new Error(nameConfig + " : " + bundle + " Bundle don't exist in file : " + pathConfig);
+            const error = new Error(`${nameConfig} : ${bundle} Bundle don't exist in file : ${pathConfig}`);
             this.log(error, "ERROR");
-            this.log("Config file : " + pathConfig);
+            this.log(`Config file : ${pathConfig}`);
             this.log(yml.system.bundles);
           }
           try {
-            let link = path.resolve(this.publicPath, bundle);
-            let stat = fs.lstatSync(link);
+            const link = path.resolve(this.publicPath, bundle);
+            const stat = fs.lstatSync(link);
             if (stat) {
               exist = fs.existsSync(fs.readlinkSync(link));
               if (!exist) {
                 fs.unlinkSync(link);
-                this.log("REMOVE LINK : " + link);
+                this.log(`REMOVE LINK : ${link}`);
               }
             }
           } catch (e) {}
@@ -639,13 +670,13 @@ class Kernel extends nodefony.Service {
     }
   }
 
-  readGeneratedConfig() {
+  readGeneratedConfig () {
     let exist = null;
     try {
       exist = fs.existsSync(this.generateConfigPath);
       if (exist) {
         try {
-          let yml = yaml.load(fs.readFileSync(this.generateConfigPath, 'utf8'));
+          const yml = yaml.load(fs.readFileSync(this.generateConfigPath, "utf8"));
           this.checkBundlesExist(yml, "Generated Config", this.generateConfigPath, true);
           return yml;
         } catch (e) {
@@ -659,7 +690,7 @@ class Kernel extends nodefony.Service {
     }
   }
 
-  searchPackage(name, mypath) {
+  searchPackage (name, mypath) {
     let res = null;
     let error = null;
     if (mypath && mypath !== "*") {
@@ -673,30 +704,28 @@ class Kernel extends nodefony.Service {
               if (myrequire) {
                 try {
                   res = myrequire.resolve(`${name}`);
-                  let version = myrequire(path.resolve(path.dirname(res), "package.json")).version;
+                  const {version} = myrequire(path.resolve(path.dirname(res), "package.json"));
                   if (version === mypath) {
                     if (this.type === "SERVER") {
                       this.log(`Find NPM Bundle Package : ${name}@${mypath} in : ${res}`, "DEBUG");
                     }
                     return `${name}`;
-                  } else {
-                    throw new Error(`Can not found NPM Bundle Package : ${name}@${mypath}`);
                   }
+                  throw new Error(`Can not found NPM Bundle Package : ${name}@${mypath}`);
                 } catch (e) {
                   error = e;
                 }
               }
               try {
                 res = require.resolve(`${name}`);
-                let version = myrequire(path.resolve(path.dirname(res), "package.json")).version;
+                const {version} = myrequire(path.resolve(path.dirname(res), "package.json"));
                 if (version === mypath) {
                   if (this.type === "SERVER") {
                     this.log(`Find NPM Bundle Package : ${name}@${mypath} in : ${res}`, "DEBUG");
                   }
                   return `${name}`;
-                } else {
-                  throw new Error(`Can not found NPM Bundle Package : ${name}@${mypath}`);
                 }
+                throw new Error(`Can not found NPM Bundle Package : ${name}@${mypath}`);
               } catch (e) {
                 if (error) {
                   throw error;
@@ -721,10 +750,10 @@ class Kernel extends nodefony.Service {
           require.resolve(res);
         } catch (e) {
           // no main in package.json
-          let bundleName = this.getBundleName(name);
+          const bundleName = this.getBundleName(name);
           if (bundleName) {
             try {
-              require.resolve(path.resolve(res, bundleName + "Bundle.js"));
+              require.resolve(path.resolve(res, `${bundleName}Bundle.js`));
             } catch (e) {
               this.log(e, "ERROR");
               throw new Error(`${name} is not a Bundle Package`);
@@ -800,7 +829,7 @@ class Kernel extends nodefony.Service {
     } catch (e) {}
     try {
       res = null;
-      res = path.resolve(this.nodefonyPath, '..', '..', "src", "bundles", name);
+      res = path.resolve(this.nodefonyPath, "..", "..", "src", "bundles", name);
       require.resolve(res);
       if (this.type === "SERVER") {
         this.log(`Find Core Local Bundle Package : ${name} in : ${res}`, "DEBUG");
@@ -809,7 +838,7 @@ class Kernel extends nodefony.Service {
     } catch (e) {}
     try {
       res = null;
-      const globalPath = path.resolve(process.execPath, '..', '..', 'lib', 'node_modules', "nodefony", "bundle");
+      const globalPath = path.resolve(process.execPath, "..", "..", "lib", "node_modules", "nodefony", "bundle");
       res = path.resolve(globalPath, `@nodefony/${name}`);
       require.resolve(res);
       if (this.type === "SERVER") {
@@ -819,7 +848,7 @@ class Kernel extends nodefony.Service {
     } catch (e) {}
     try {
       res = null;
-      const globalPath = path.resolve(process.execPath, '..', '..', 'lib', 'node_modules', "nodefony", 'node_modules');
+      const globalPath = path.resolve(process.execPath, "..", "..", "lib", "node_modules", "nodefony", "node_modules");
       res = path.resolve(globalPath, `@nodefony/${name}`);
       require.resolve(res);
       if (this.type === "SERVER") {
@@ -837,12 +866,12 @@ class Kernel extends nodefony.Service {
   /**
    *  @method boot
    */
-  async boot() {
+  async boot () {
     /*
      *  BUNDLES
      */
     this.configBundle = this.getConfigBunbles();
-    let bundles = [];
+    const bundles = [];
     let res = null;
     try {
       res = this.searchPackage("http-bundle");
@@ -853,23 +882,24 @@ class Kernel extends nodefony.Service {
         res = this.searchPackage("security-bundle");
         bundles.push(res);
       }
-      /*if (this.settings.system.documentation) {
+
+      /* if (this.settings.system.documentation) {
         res = this.searchPackage("documentation-bundle");
         bundles.push(res);
       }*/
       switch (this.settings.orm) {
-        case "sequelize":
-          res = this.searchPackage("sequelize-bundle");
-          bundles.push(res);
-          break;
-        case "mongoose":
-          res = this.searchPackage("mongoose-bundle");
-          bundles.push(res);
-          break;
-        default:
-          let error = new Error("nodefony can't load ORM : " + this.settings.orm);
-          this.log(error, "ERROR");
-          throw error;
+      case "sequelize":
+        res = this.searchPackage("sequelize-bundle");
+        bundles.push(res);
+        break;
+      case "mongoose":
+        res = this.searchPackage("mongoose-bundle");
+        bundles.push(res);
+        break;
+      default:
+        const error = new Error(`nodefony can't load ORM : ${this.settings.orm}`);
+        this.log(error, "ERROR");
+        throw error;
       }
       if (this.settings.system.realtime) {
         res = this.searchPackage("realtime-bundle");
@@ -913,36 +943,34 @@ class Kernel extends nodefony.Service {
     }
 
     switch (this.isInstall()) {
-      case "install":
-        return await this.install(bundles)
-          .catch(e => {
-            throw e;
-          });
-      case "rebuild":
-        return await this.rebuild(bundles)
-          .catch(e => {
-            throw e;
-          });
-      default:
-        return await this.preRegister(bundles)
-          .then(() => {
-            return this;
-          })
-          .catch(e => {
-            throw e;
-          });
+    case "install":
+      return await this.install(bundles)
+        .catch((e) => {
+          throw e;
+        });
+    case "rebuild":
+      return await this.rebuild(bundles)
+        .catch((e) => {
+          throw e;
+        });
+    default:
+      return await this.preRegister(bundles)
+        .then(() => this)
+        .catch((e) => {
+          throw e;
+        });
     }
   }
 
-  async install(coreBundles = []) {
-    let bundles = coreBundles.concat(this.configBundle, [this.appPath]);
+  async install (coreBundles = []) {
+    const bundles = coreBundles.concat(this.configBundle, [this.appPath]);
     try {
       for (let i = 0; i < bundles.length; i++) {
         let bundleFile = null;
         try {
           bundleFile = new nodefony.fileClass(path.resolve(bundles[i], "package.json"));
         } catch (e) {
-          let Path = this.isNodeModule(bundles[i]);
+          const Path = this.isNodeModule(bundles[i]);
           if (Path) {
             bundleFile = new nodefony.fileClass(Path);
           } else {
@@ -953,14 +981,14 @@ class Kernel extends nodefony.Service {
         if (this.isCore) {
           await this.cli.installPackage(bundleFile, "development");
         } else {
-          let dir = path.basename(bundleFile.dirName);
+          const dir = path.basename(bundleFile.dirName);
           if (!this.isBundleCore(dir)) {
             await this.cli.installPackage(bundleFile, "development");
           }
         }
       }
       return await this.preRegister(coreBundles)
-        .catch(e => {
+        .catch((e) => {
           throw e;
         });
     } catch (e) {
@@ -969,15 +997,15 @@ class Kernel extends nodefony.Service {
     }
   }
 
-  async rebuild(coreBundles) {
-    let bundles = coreBundles.concat(this.configBundle, [this.appPath]);
+  async rebuild (coreBundles) {
+    const bundles = coreBundles.concat(this.configBundle, [this.appPath]);
     try {
       for (let i = 0; i < bundles.length; i++) {
         let bundleFile = null;
         try {
           bundleFile = new nodefony.fileClass(path.resolve(bundles[i], "package.json"));
         } catch (e) {
-          let Path = this.isNodeModule(bundles[i]);
+          const Path = this.isNodeModule(bundles[i]);
           if (Path) {
             bundleFile = new nodefony.fileClass(Path);
           } else {
@@ -985,10 +1013,10 @@ class Kernel extends nodefony.Service {
             continue;
           }
         }
-        await this.cli.rebuildPackage(bundleFile, "development");
+        await this.cli.rebuildPackage(bundleFile, "production");
       }
       return await this.preRegister(coreBundles)
-        .catch(e => {
+        .catch((e) => {
           throw e;
         });
     } catch (e) {
@@ -997,38 +1025,48 @@ class Kernel extends nodefony.Service {
     }
   }
 
-  async preRegister(bundles) {
+  async preRegister (bundles) {
     try {
-      //this.fire("onPreRegister", this);
-      await this.emitAsync("onPreRegister", this);
+      // this.fire("onPreRegister", this);
+      await this.emitAsync("onPreRegister", this)
+        .catch((e) => {
+          throw e;
+        });
       this.preRegistered = true;
+      return await this.registerBundles(bundles)
+        .then(async (res) => {
+          this.preboot = true;
+          // this.fire("onPreBoot", this);
+          await this.emitAsync("onPreBoot", this);
+          this.log(res, "DEBUG", "REGISTER BUNDLES");
+          return await this.registerBundles(this.configBundle)
+            .then(async (res) => {
+              if (res.length) {
+                this.log(res, "DEBUG", "REGISTER BUNDLES");
+              }
+              // this.fire("onRegister", this);
+              await this.emitAsync("onRegister", this);
+              return await this.initializeBundles()
+                .catch((e) => {
+                  throw e;
+                });
+            })
+            .catch((e) => {
+              throw e;
+            });
+        })
+        .catch((e) => {
+          throw e;
+        });
     } catch (e) {
-      this.log(e);
-    }
-    return await this.registerBundles(bundles)
-      .then(async (res) => {
-        this.preboot = true;
-        //this.fire("onPreBoot", this);
-        await this.emitAsync("onPreBoot", this);
-        this.log(res, "DEBUG", "REGISTER BUNDLES");
-        return await this.registerBundles(this.configBundle)
-          .then(async (res) => {
-            if (res.length) {
-              this.log(res, "DEBUG", "REGISTER BUNDLES");
-            }
-            //this.fire("onRegister", this);
-            await this.emitAsync("onRegister", this);
-            return await this.initializeBundles();
-          });
-      })
-      .catch(e => {
-        throw e;
-      });
+      this.log(e, "ERROR");
+      throw e;
+    }
   }
 
-  async onReady() {
+  async onReady () {
     return new Promise((resolve, reject) => {
-      //process.nextTick(() => {
+      // process.nextTick(() => {
       try {
         if (this.type === "SERVER") {
           this.initServers();
@@ -1048,15 +1086,15 @@ class Kernel extends nodefony.Service {
         return reject(e);
       }
     });
-    //});
+    // });
   }
 
   /**
    *  initialisation  all bundles
    *  @method initializeBundles
    */
-  async initializeBundles() {
-    let tab = [];
+  async initializeBundles () {
+    const tab = [];
     try {
       this.app = await this.initApplication();
       await this.emitAsync("onPostRegister", this);
@@ -1071,20 +1109,21 @@ class Kernel extends nodefony.Service {
       this.log(e, "WARNING", "EVENTS onBoot");
       throw e;
     }
-    for (let name in this.bundles) {
-      this.log("\x1b[36m INITIALIZE Bundle :  " + name.toUpperCase() + "\x1b[0m", "DEBUG");
+    for (const name in this.bundles) {
+      this.log(`\x1b[36m INITIALIZE Bundle :  ${name.toUpperCase()}\x1b[0m`, "DEBUG");
       try {
         tab.push(await this.bundles[name].initialize());
       } catch (e) {
-        this.log(e, "ERROR");
-        continue;
+        // this.log(e, "ERROR");
+        throw e;
+        // continue;
       }
     }
 
     // BOOT
     tab.length = 0;
     try {
-      //this.fire("onBoot", this, tab);
+      // this.fire("onBoot", this, tab);
       await this.emitAsync("onBoot", this, tab);
     } catch (e) {
       this.log(e, "WARNING", "EVENTS onBoot");
@@ -1092,13 +1131,13 @@ class Kernel extends nodefony.Service {
     }
     this.booted = true;
 
-    for (let name in this.bundles) {
-      this.log("\x1b[36m BOOT Bundle :  " + name.toUpperCase() + "\x1b[0m", "DEBUG");
+    for (const name in this.bundles) {
+      this.log(`\x1b[36m BOOT Bundle :  ${name.toUpperCase()}\x1b[0m`, "DEBUG");
       try {
         tab.push(await this.bundles[name].boot());
       } catch (e) {
         this.log(e, "ERROR");
-        //continue;
+        // continue;
         throw e;
       }
     }
@@ -1106,7 +1145,8 @@ class Kernel extends nodefony.Service {
       await this.loadCommand();
     } else {
       await this.cli.assetInstall();
-      /*if (!fs.existsSync(this.cacheLink)) {
+
+      /* if (!fs.existsSync(this.cacheLink)) {
         try {
           fs.mkdirSync(this.cacheLink);
           this.cli.assetInstall();
@@ -1116,18 +1156,18 @@ class Kernel extends nodefony.Service {
       }*/
     }
 
-    /*let bundles = [];
+    /* let bundles = [];
     for await (let boot of this.promisesBundleReady) {
       this.log(`End Waiting Bundle Ready  ${boot.name}`, "DEBUG");
       bundles.push(boot);
     }*/
-    //await this.emitAsync("onReady", this, tab);
+    // await this.emitAsync("onReady", this, tab);
     try {
-      //this.fire("onReady", this, bundles);
+      // this.fire("onReady", this, bundles);
       await this.emitAsync("onReady", this, tab);
     } catch (e) {
       this.log(e, "WARNING", "EVENTS onReady");
-      throw e
+      throw e;
     }
     this.ready = true;
 
@@ -1142,7 +1182,7 @@ class Kernel extends nodefony.Service {
           return command;
         })
         .catch((error) => {
-          //this.log(error, "ERROR", `COMMAND`);
+          // this.log(error, "ERROR", `COMMAND`);
           throw error;
         });
     }
@@ -1156,15 +1196,19 @@ class Kernel extends nodefony.Service {
       });
   }
 
-  getOrm() {
+  getOrm () {
     return this.settings.orm;
   }
 
-  getORM() {
+  getOrmStrategy () {
+    return this.getORM().settings.strategy;
+  }
+
+  getORM () {
     return this.get(this.getOrm());
   }
 
-  initServers() {
+  initServers () {
     // create HTTP server
     let http = null;
     let http2 = null;
@@ -1194,11 +1238,11 @@ class Kernel extends nodefony.Service {
    *  CLUSTERS
    *
    */
-  clusterIsMaster() {
+  clusterIsMaster () {
     return cluster.isMaster;
   }
 
-  initCluster() {
+  initCluster () {
     this.processId = process.pid;
     this.process = process;
     if (this.console && this.cli && this.cli.commander && this.cli.commander.opts().json) {
@@ -1212,7 +1256,7 @@ class Kernel extends nodefony.Service {
       this.workerId = cluster.worker.id;
       this.worker = cluster.worker;
       this.fire("onCluster", "WORKER", this, process);
-      //process.on("message", this.listen(this, "onMessage"));
+      // process.on("message", this.listen(this, "onMessage"));
       process.on("message", (msg) => {
         this.fire("onMessage", msg);
       });
@@ -1222,24 +1266,24 @@ class Kernel extends nodefony.Service {
     }
   }
 
-  fire() {
+  fire () {
     this.log(`${colorLogEvent} ${arguments[0]}`, "DEBUG");
     return super.fire.apply(this, arguments);
   }
 
-  emit() {
+  emit () {
     this.log(`${colorLogEvent} ${arguments[0]}`, "DEBUG");
     return super.fire.apply(this, arguments);
   }
 
-  emitAsync() {
+  emitAsync () {
     this.log(`${colorLogEvent} ${arguments[0]}`, "DEBUG");
     return super.emitAsync.apply(this, arguments);
   }
 
-  sendMessage(message) {
+  sendMessage (message) {
     return process.send({
-      type: 'process:msg',
+      type: "process:msg",
       data: message
     });
   }
@@ -1247,7 +1291,7 @@ class Kernel extends nodefony.Service {
   /**
    *  @method initializeLog
    */
-  initializeLog() {
+  initializeLog () {
     if (this.type === "CONSOLE") {
       return this.cli.initSyslog(this.environment, this.debug);
     }
@@ -1263,15 +1307,15 @@ class Kernel extends nodefony.Service {
   /**
    *  @method getTemplate
    */
-  getTemplate(name) {
+  getTemplate (name) {
     return nodefony.templates[name];
   }
 
   /**
    *  @method initTemplate
    */
-  initTemplate() {
-    let classTemplate = this.getTemplate(this.settings.templating);
+  initTemplate () {
+    const classTemplate = this.getTemplate(this.settings.templating);
     this.templating = new classTemplate(this.container, this.settings[this.settings.templating]);
     this.set("templating", this.templating);
   }
@@ -1279,7 +1323,7 @@ class Kernel extends nodefony.Service {
   /**
    *  @method log
    */
-  log(pci, severity, msgid, msg) {
+  log (pci, severity, msgid, msg) {
     if (!msgid) {
       msgid = this.cli.clc.magenta("KERNEL");
     }
@@ -1291,16 +1335,16 @@ class Kernel extends nodefony.Service {
    *  @method getBundle
    *  @param {String} name
    */
-  getBundle(name) {
+  getBundle (name) {
     this.regBundleName.test(name);
-    let res = regBundleName.exec(name);
+    const res = regBundleName.exec(name);
     if (res) {
       name = res[1];
     }
     if (name === "App" || name === "app") {
       return this.bundles.app;
     }
-    for (let ns in this.bundles) {
+    for (const ns in this.bundles) {
       if (ns === name) {
         return this.bundles[ns];
       }
@@ -1313,7 +1357,7 @@ class Kernel extends nodefony.Service {
    *  @method getBundles
    *  @param {String} name
    */
-  getBundles(name) {
+  getBundles (name) {
     if (name) {
       return this.getBundle(name);
     }
@@ -1325,77 +1369,77 @@ class Kernel extends nodefony.Service {
    *  @method getBundleName
    *  @param {String} str
    */
-  getBundleName(str) {
+  getBundleName (str) {
     if (str === "app") {
       return str;
     }
     let ret = null;
     switch (typeof str) {
-      case "string":
-        ret = regBundleName.exec(str);
-        if (ret) {
-          return ret[1] || ret[2];
-        }
-        throw new Error("Bundle Bad Name :" + str);
-      case "function":
-        ret = regClassBundle.exec(str.name);
-        if (ret) {
-          return ret[1];
-        }
-        throw new Error("Bundle Bad Name :" + str.name);
-      default:
-        throw new Error("Bundle Bad Name :" + str);
+    case "string":
+      ret = regBundleName.exec(str);
+      if (ret) {
+        return ret[1] || ret[2];
+      }
+      throw new Error(`Bundle Bad Name :${str}`);
+    case "function":
+      ret = regClassBundle.exec(str.name);
+      if (ret) {
+        return ret[1];
+      }
+      throw new Error(`Bundle Bad Name :${str.name}`);
+    default:
+      throw new Error(`Bundle Bad Name :${str}`);
     }
   }
 
-  getBundleClass(Class, Path) {
+  getBundleClass (Class, Path) {
     try {
       switch (true) {
-        case (Class instanceof nodefony.fileClass):
-          return this.getBundleClass(require(Class.path), require.resolve(Class.path));
-        case (typeof Class === "function"):
-          if (Class.toString().indexOf("class") >= 0) {
-            Class.prototype.path = path.dirname(Path);
-            Class.prototype.autoLoader = this.autoLoader;
-            return {
-              class: Class,
-              name: this.getBundleName(Class)
-            };
-          } else {
-            throw new Error(`getBundleClass Bad Bundle Class : ${Class.toString()} Path : ${Path}`);
-          }
-          break;
-        case (typeof Class === "string"):
-          return this.getBundleClass(require(Class), require.resolve(Class));
-        default:
-          throw new Error(`getBundleClass Bad Bundle Class : ${typeof Class} Path : ${Path}`);
+      case Class instanceof nodefony.fileClass:
+        return this.getBundleClass(require(Class.path), require.resolve(Class.path));
+      case typeof Class === "function":
+        if (Class.toString().indexOf("class") >= 0) {
+          Class.prototype.path = path.dirname(Path);
+          Class.prototype.autoLoader = this.autoLoader;
+          return {
+            class: Class,
+            name: this.getBundleName(Class)
+          };
+        }
+        throw new Error(`getBundleClass Bad Bundle Class : ${Class.toString()} Path : ${Path}`);
+
+        break;
+      case typeof Class === "string":
+        return this.getBundleClass(require(Class), require.resolve(Class));
+      default:
+        throw new Error(`getBundleClass Bad Bundle Class : ${typeof Class} Path : ${Path}`);
       }
     } catch (e) {
       throw e;
     }
   }
 
-  loadBundle(file, loader) {
+  loadBundle (file, loader) {
     try {
-      let bundle = this.getBundleClass(file);
+      const bundle = this.getBundleClass(file);
       try {
         this.log(`${bundle.name} : ${file.path}`, "DEBUG", "LOADER BUNDLE");
         this.bundles[bundle.name] = new bundle.class(bundle.name, this, this.container);
         this.bundles[bundle.name].loader = loader;
-        //console.log(bundle.name, this.notificationsCenter._events)
+        // console.log(bundle.name, this.notificationsCenter._events)
       } catch (e) {
         throw e;
       }
-      //this.bundles[bundle.name].once("onReady", promiseBundleReady.call(this));
+      // this.bundles[bundle.name].once("onReady", promiseBundleReady.call(this));
       return this.bundles[bundle.name];
     } catch (e) {
       throw e;
     }
   }
 
-  isPathExist(Path) {
+  isPathExist (Path) {
     try {
-      let mypath = path.resolve(Path);
+      const mypath = path.resolve(Path);
       if (fs.existsSync(mypath)) {
         return mypath;
       }
@@ -1404,11 +1448,11 @@ class Kernel extends nodefony.Service {
     }
   }
 
-  isConsole() {
+  isConsole () {
     return this.type === "CONSOLE";
   }
 
-  isInstall() {
+  isInstall () {
     if (this.cli.command === "nodefony" &&
       this.cli.task === "bundles" &&
       this.cli.action === "install") {
@@ -1436,29 +1480,29 @@ class Kernel extends nodefony.Service {
     return false;
   }
 
-  async isBundleDirectory(dir) {
-    let directory = this.isPathExist(dir);
+  async isBundleDirectory (dir) {
+    const directory = this.isPathExist(dir);
     if (directory) {
-      let finder = new nodefony.Finder2({
+      const finder = new nodefony.Finder2({
         followSymLink: true,
         excludeDir: nodefony.Bundle.excludeDir(),
         exclude: nodefony.Bundle.exclude(),
         recurse: false,
         match: this.regBundle
       });
-      let result = await finder.in(directory);
+      const result = await finder.in(directory);
       return result.getFiles();
     }
     return false;
   }
 
-  isNodeModule(module) {
-    //console.log(module)
+  isNodeModule (module) {
+    // console.log(module)
     let error = null;
     try {
       return require.resolve(module);
     } catch (e) {
-      //this.log(e, "ERROR");
+      // this.log(e, "ERROR");
       error = e;
     }
     try {
@@ -1474,29 +1518,31 @@ class Kernel extends nodefony.Service {
    *  @method
    *  @param {array} bundles
    */
-  registerBundles(bundles) {
+  registerBundles (bundles) {
     return new Promise(async (resolve, reject) => {
       switch (nodefony.typeOf(bundles)) {
-        case "array":
+      case "array":
+        try {
           for (let i = 0; i < bundles.length; i++) {
             let Path = await this.isBundleDirectory(bundles[i]);
             if (Path && Path.length) {
               try {
-                let bundle = this.loadBundle(Path[0], "filesystem");
+                const bundle = this.loadBundle(Path[0], "filesystem");
                 await bundle.find();
               } catch (e) {
                 this.log(e, "ERROR");
+                throw e;
               }
             } else {
               try {
                 Path = this.isNodeModule(bundles[i]);
                 if (Path) {
-                  let bundle = this.loadBundle(Path, "package");
+                  const bundle = this.loadBundle(Path, "package");
                   await bundle.find();
                 } else {
                   this.log("GLOBAL CONFIG REGISTER : ", "INFO");
                   this.log(this.configBundle, "INFO");
-                  let gene = this.readGeneratedConfig();
+                  const gene = this.readGeneratedConfig();
                   if (gene) {
                     this.log("GENERATED CONFIG REGISTER file ./config/GeneratedConfig.yml : ", "INFO");
                     this.log(gene, "INFO");
@@ -1504,12 +1550,16 @@ class Kernel extends nodefony.Service {
                 }
               } catch (e) {
                 this.log(e, "ERROR");
+                throw e;
               }
             }
           }
           return resolve(bundles);
-        default:
-          return reject(new Error("registerBundles argument bundles must be an array "));
+        } catch (e) {
+          return reject(e);
+        }
+      default:
+        return reject(new Error("registerBundles argument bundles must be an array "));
       }
     });
   }
@@ -1518,9 +1568,9 @@ class Kernel extends nodefony.Service {
    *  initialisation application bundle
    *  @method initApplication
    */
-  async initApplication() {
-    let app = class appBundle extends nodefony.Bundle {
-      constructor(name, myKernel, myContainer) {
+  async initApplication () {
+    const app = class appBundle extends nodefony.Bundle {
+      constructor (name, myKernel, myContainer) {
         super(name, myKernel, myContainer);
       }
     };
@@ -1531,11 +1581,11 @@ class Kernel extends nodefony.Service {
     await this.bundles.app.find();
     // OVERRIDE VIEWS BUNDLE in APP DIRECTORY
     this.once("onBoot", async () => {
-      for (let bundle in this.bundles) {
+      for (const bundle in this.bundles) {
         if (bundle === "app") {
           continue;
         }
-        let result = this.bundles.app.resourcesFiles.find(bundle + "-bundle");
+        const result = this.bundles.app.resourcesFiles.find(`${bundle}-bundle`);
         if (result.length) {
           try {
             this.bundles[bundle].registerI18n(null, result);
@@ -1548,93 +1598,135 @@ class Kernel extends nodefony.Service {
     return this.bundles.app;
   }
 
+  // CONFIG
+  readConfigFile (bundle, Path, callback) {
+    try {
+      this.log(`${bundle} CONFIG LOAD FILE :${Path}`, "DEBUG", "KERNEL READER");
+      return this.reader.readConfig(Path, this.name, callback);
+    } catch (e) {
+      this.log(e, "ERROR", `BUNDLE ${bundle} CONFIG :${Path}`);
+      throw e;
+    }
+  }
+
+  readRoutingFile (bundle, Path) {
+    // ROUTING
+    try {
+      this.log(`${bundle} ROUTER LOAD FILE :${Path}`, "DEBUG", "KERNEL READER");
+      const router = this.get("router");
+      if (router) {
+        return router.reader(Path, this.name);
+      }
+      this.log(`${bundle} Router service not ready to LOAD FILE :${Path}`, "WARNING", "KERNEL READER");
+    } catch (e) {
+      this.log(e, "ERROR", `BUNDLE ${this.name.toUpperCase()} CONFIG ROUTING :${Path}`);
+      throw e;
+    }
+  }
+
+  readServicesFile (bundle, Path, callback) {
+    try {
+      this.log(`${bundle} LOAD FILE :${Path}`, "DEBUG", "KERNEL READER");
+      return this.get("injection").reader(Path, this.name);
+    } catch (e) {
+      this.log(e, "ERROR", `BUNDLE ${this.name.toUpperCase()} CONFIG SERVICE :${Path}`);
+      throw e;
+    }
+  }
+
+  readSecurityFile (bundle, Path, callback) {
+    try {
+      const firewall = this.get("security");
+      if (firewall) {
+        this.log(`${bundle} SECURITY LOAD FILE :${Path}`, "DEBUG", "KERNEL READER");
+        return firewall.reader(Path, this.name);
+      }
+      this.log(`${bundle} SECURITY LOAD FILE :${Path} BUT SERVICE NOT READY`, "WARNING");
+    } catch (e) {
+      this.log(e, "ERROR", `BUNDLE ${this.name.toUpperCase()} CONFIG SECURITY :${Path}`);
+      throw e;
+    }
+  }
+
+  findConfigFile (ele, callback) {
+    const name = this.name.toUpperCase();
+    switch (true) {
+    case (/^config\..*$/).test(ele.name):
+      try {
+        return this.kernel.readConfigFile.call(this, name, ele.path, callback);
+      } catch (e) {
+        throw e;
+      }
+    case (/^routing\..*$/).test(ele.name):
+      try {
+        return this.kernel.readRoutingFile.call(this, name, ele.path, callback);
+      } catch (e) {
+        throw e;
+      }
+    case (/^services\..*$/).test(ele.name):
+      try {
+        return this.kernel.readServicesFile.call(this, name, ele.path, callback);
+      } catch (e) {
+        throw e;
+      }
+    case (/^security\..*$/).test(ele.name):
+      try {
+        return this.kernel.readSecurityFile.call(this, name, ele.path, callback);
+      } catch (e) {
+        throw e;
+      }
+    }
+  }
+
   /**
    *
    *  @method readConfig
    */
-  readConfig(error, result, callback) {
-    let name = this.name.toUpperCase();
+  readConfig (error, result, callback) {
     if (error) {
-      this.log(error, "ERROR");
+      throw error;
     } else {
+      if (!result) {
+        throw new Error("readConfig no result found");
+      }
       result.forEach((ele) => {
-        switch (true) {
-          case /^config\..*$/.test(ele.name):
-            try {
-              this.log(name + " CONFIG LOAD FILE :" + ele.path, "DEBUG", "KERNEL READER");
-              this.reader.readConfig(ele.path, this.name, callback);
-            } catch (e) {
-              this.log(e, "ERROR", "BUNDLE " + name + " CONFIG :" + ele.path);
-            }
-            break;
-          case /^routing\..*$/.test(ele.name):
-            // ROUTING
-            try {
-              this.log(name + " ROUTER LOAD FILE :" + ele.path, "DEBUG", "KERNEL READER");
-              let router = this.get("router");
-              if (router) {
-                router.reader(ele.path, this.name);
-              } else {
-                this.log(name + " Router service not ready to LOAD FILE :" + ele.path, "WARNING", "KERNEL READER");
-              }
-            } catch (e) {
-              this.log(e, "ERROR", "BUNDLE " + this.name.toUpperCase() + " CONFIG ROUTING :" + ele.path);
-            }
-            break;
-          case /^services\..*$/.test(ele.name):
-            try {
-              this.log(name + " LOAD FILE :" + ele.path, "DEBUG", "KERNEL READER");
-              this.get("injection").reader(ele.path, this.name);
-            } catch (e) {
-              this.log(e, "ERROR", "BUNDLE " + this.name.toUpperCase() + " CONFIG SERVICE :" + ele.path);
-            }
-            break;
-          case /^security\..*$/.test(ele.name):
-            try {
-              let firewall = this.get("security");
-              if (firewall) {
-                this.log(name + " SECURITY LOAD FILE :" + ele.path, "DEBUG", "KERNEL READER");
-                firewall.reader(ele.path, this.name);
-              } else {
-                this.log(name + " SECURITY LOAD FILE :" + ele.path + " BUT SERVICE NOT READY", "WARNING");
-              }
-            } catch (e) {
-              this.log(e, "ERROR", "BUNDLE " + this.name.toUpperCase() + " CONFIG SECURITY :" + ele.path);
-            }
-            break;
+        try {
+          this.kernel.findConfigFile.call(this, ele, callback);
+        } catch (e) {
+          throw e;
         }
       });
     }
   }
 
-  memoryUsage(message) {
-    //let memory =  process.memoryUsage() ;
-    let memory = this.stats().memory;
-    for (let ele in memory) {
+  memoryUsage (message) {
+    // let memory =  process.memoryUsage() ;
+    const {memory} = this.stats();
+    for (const ele in memory) {
       switch (ele) {
-        case "rss":
-          this.log((message || ele) + " ( Resident Set Size ) PID ( " + this.processId + " ) : " + nodefony.cli.niceBytes(memory[ele]), "DEBUG", "MEMORY " + ele);
-          break;
-        case "heapTotal":
-          this.log((message || ele) + " ( Total Size of the Heap ) PID ( " + this.processId + " ) : " + nodefony.cli.niceBytes(memory[ele]), "DEBUG", "MEMORY " + ele);
-          break;
-        case "heapUsed":
-          this.log((message || ele) + " ( Heap actually Used ) PID ( " + this.processId + " ) : " + nodefony.cli.niceBytes(memory[ele]), "DEBUG", "MEMORY " + ele);
-          break;
-        case "external":
-          this.log((message || ele) + " PID ( " + this.processId + " ) : " + nodefony.cli.niceBytes(memory[ele]), "DEBUG", "MEMORY " + ele);
-          break;
+      case "rss":
+        this.log(`${message || ele} ( Resident Set Size ) PID ( ${this.processId} ) : ${nodefony.cli.niceBytes(memory[ele])}`, "DEBUG", `MEMORY ${ele}`);
+        break;
+      case "heapTotal":
+        this.log(`${message || ele} ( Total Size of the Heap ) PID ( ${this.processId} ) : ${nodefony.cli.niceBytes(memory[ele])}`, "DEBUG", `MEMORY ${ele}`);
+        break;
+      case "heapUsed":
+        this.log(`${message || ele} ( Heap actually Used ) PID ( ${this.processId} ) : ${nodefony.cli.niceBytes(memory[ele])}`, "DEBUG", `MEMORY ${ele}`);
+        break;
+      case "external":
+        this.log(`${message || ele} PID ( ${this.processId} ) : ${nodefony.cli.niceBytes(memory[ele])}`, "DEBUG", `MEMORY ${ele}`);
+        break;
       }
     }
   }
 
-  stats() {
-    let stat = {
+  stats () {
+    const stat = {
       memory: {}
-      //cpu:process.cpuUsage()
+      // cpu:process.cpuUsage()
     };
-    let memory = process.memoryUsage();
-    for (let ele in memory) {
+    const memory = process.memoryUsage();
+    for (const ele in memory) {
       stat.memory[ele] = memory[ele];
     }
     return stat;
@@ -1644,12 +1736,12 @@ class Kernel extends nodefony.Service {
    *
    *  @method terminate
    */
-  async terminate(code) {
+  async terminate (code) {
     if (code === undefined) {
       code = 0;
     }
     if (this.debug) {
-      console.trace(code);
+      console.trace(`terminate : ${code}`);
     }
     try {
       if (fs.existsSync(this.cacheLink)) {
@@ -1665,7 +1757,7 @@ class Kernel extends nodefony.Service {
       code = 1;
     }
     process.nextTick(() => {
-      this.log("NODEFONY Kernel Life Cycle Terminate CODE : " + code, "INFO");
+      this.log(`NODEFONY Kernel Life Cycle Terminate CODE : ${code}`, "INFO");
       try {
         nodefony.cli.quit(code);
       } catch (e) {