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

package/nodefony.es6

@@ -1,6 +1,12 @@
-const execSync = require('child_process').execSync;
+const {execSync} = require("child_process");
 const uuid = require("uuid");
 
+const myobj = {};
+const hasOwn = myobj.hasOwnProperty;
+const fnToString = hasOwn.toString;
+const ObjectFunctionString = fnToString.call(Object);
+const getProto = Object.getPrototypeOf;
+
 /**
  *  The class is a **`Nodefony Nodefony `** .
  *  @class Nodefony
@@ -8,12 +14,9 @@ const uuid = require("uuid");
  *  @module Nodefony
  *
  */
-const myObj = {};
-
 class Nodefony {
-
-  constructor(context) {
-    //this.require = require;
+  constructor (context) {
+    // this.require = require;
     this.path = path.resolve(__dirname);
     this.io = {};
     this.context = context;
@@ -52,7 +55,7 @@ class Nodefony {
     this.appConfig = null;
     this.projectName = "nodefony";
     this.appKernel = null;
-    this.isRegExp = require('lodash.isregexp');
+    this.isRegExp = require("lodash.isregexp");
     this.isCore = false;
     this.isElectron = this.isElectronContext();
     this.yarn = this.checkYarn();
@@ -61,7 +64,7 @@ class Nodefony {
     this.checkTrunk();
   }
 
-  checkTrunk(cwd = path.resolve(".")) {
+  checkTrunk (cwd = path.resolve(".")) {
     this.isTrunk = this.isNodefonyTrunk(cwd);
     if (this.isTrunk) {
       this.builded = this.isBuilded(cwd);
@@ -74,7 +77,7 @@ class Nodefony {
     }
   }
 
-  isBuilded(cwd = path.resolve(".")) {
+  isBuilded (cwd = path.resolve(".")) {
     try {
       fs.lstatSync(path.resolve(cwd, "node_modules"));
       return true;
@@ -83,15 +86,16 @@ class Nodefony {
     }
   }
 
-  generateId(...args) {
+  generateId (...args) {
     return uuid.v4(...args);
   }
 
-  setConfig(cwd = path.resolve(".")) {
+  setConfig (cwd = path.resolve(".")) {
     try {
       this.projectPackage = require(path.resolve(cwd, "package.json"));
       this.projectVersion = this.projectPackage.version;
       this.projectName = this.projectPackage.name;
+      this.context.kernel = {};
       this.kernelConfig = this.loadConfig(this.kernelConfigPath);
       this.appConfig = this.loadConfig(this.appConfigPath, console.warn);
       this.packageManager = this.kernelConfig.packageManager || "npm";
@@ -99,21 +103,21 @@ class Nodefony {
       if (!this.Error) {
         this.Error = require(path.resolve(__dirname, "error.es6"));
       }
-      let error = new this.Error(e);
+      const error = new this.Error(e);
       throw error;
     }
   }
 
-  setPm2Config() {
+  setPm2Config () {
     if (this.builded) {
       this.pm2Config = require(this.pm2ConfigPath);
     }
     return this.pm2Config;
   }
 
-  loadConfig(file, log) {
+  loadConfig (file, log) {
     try {
-      let ext = path.extname(file);
+      const ext = path.extname(file);
       switch (ext) {
       case ".js":
         return require(file);
@@ -122,24 +126,24 @@ class Nodefony {
       }
     } catch (e) {
       if (log) {
-        //log(e);
+        // log(e);
         return {};
       }
       throw e;
     }
   }
 
-  readFileSync(file) {
+  readFileSync (file) {
     try {
       return fs.readFileSync(file, {
-        encoding: 'utf8'
+        encoding: "utf8"
       });
     } catch (e) {
       throw e;
     }
   }
 
-  isCoreTrunk() {
+  isCoreTrunk () {
     if (this.isTrunk) {
       if (this.projectPackage.name === "nodefony-core") {
         return true;
@@ -154,19 +158,19 @@ class Nodefony {
     return false;
   }
 
-  isFunction(it) {
-    return Object.prototype.toString.call(it) === '[object Function]';
+  isFunction (it) {
+    return Object.prototype.toString.call(it) === "[object Function]";
   }
 
-  isArray(it) {
-    return Object.prototype.toString.call(it) === '[object Array]';
+  isArray (it) {
+    return Object.prototype.toString.call(it) === "[object Array]";
   }
 
-  isError(it) {
+  isError (it) {
     return nodefony.Error.isError(it);
   }
 
-  isContainer(container) {
+  isContainer (container) {
     if (container) {
       if (container instanceof nodefony.Container) {
         return true;
@@ -179,35 +183,39 @@ class Nodefony {
     return false;
   }
 
-  isPromise(obj) {
+  isPromise (obj) {
     switch (true) {
     case obj instanceof Promise:
     case obj instanceof BlueBird:
       return true;
     default:
-      return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
+      return Boolean(obj) && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
     }
   }
 
-  isUndefined(value) {
+  isUndefined (value) {
     return value === undefined;
   }
 
-  isPlainObject(obj) {
+  isEmptyObject (obj) {
+    let name;
+    for (name in obj) {
+      return false;
+    }
+    return true;
+  }
+
+  isPlainObject (obj) {
     let proto, Ctor;
-    // Detect obvious negatives
-    // Use toString instead of jQuery.type to catch host objects
-    if (!obj || myObj.toString.call(obj) !== "[object Object]") {
+    if (!obj || toString.call(obj) !== "[object Object]") {
       return false;
     }
-    proto = Object.getPrototypeOf(obj);
-    // Objects with no prototype (e.g., `Object.create( null )`) are plain
+    proto = getProto(obj);
     if (!proto) {
       return true;
     }
-    // Objects with prototype are plain iff they were constructed by a global Object function
-    Ctor = myObj.hasOwnProperty.call(proto, "constructor") && proto.constructor;
-    return typeof Ctor === "function" && myObj.hasOwnProperty.toString.call(Ctor) === myObj.hasOwnProperty.toString.call(Object);
+    Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
+    return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
   }
 
   /**
@@ -215,10 +223,9 @@ class Nodefony {
    *  @param  value
    *  @return {String} type of value
    */
-  typeOf(value) {
-    let t = typeof value;
-    if (t === 'object') {
-
+  typeOf (value) {
+    const t = typeof value;
+    if (t === "object") {
       if (value === null) {
         return null;
       }
@@ -229,7 +236,7 @@ class Nodefony {
         return "array";
       }
       if (this.isFunction(value)) {
-        return 'function';
+        return "function";
       }
       if (value instanceof Date) {
         return "date";
@@ -246,19 +253,17 @@ class Nodefony {
       if (this.isError(value)) {
         return "Error";
       }
-    } else {
-      if (t === 'function' && typeof value.call === 'undefined') {
-        return 'object';
-      }
+    } else if (t === "function" && typeof value.call === "undefined") {
+      return "object";
     }
     return t;
   }
 
-  extend() {
+  extend () {
     let options, name, src, copy, copyIsArray, clone,
       target = arguments[0] || {},
       i = 1,
-      length = arguments.length,
+      {length} = arguments,
       deep = false;
 
     // Handle a deep copy situation
@@ -269,35 +274,38 @@ class Nodefony {
       i++;
     }
     // Handle case when target is a string or something (possible in deep copy)
-    if (typeof target !== "object" && this.isFunction(target)) {
+    if (typeof target !== "object" && typeof target !== "function") {
       target = {};
     }
-    // Extend jQuery itself if only one argument is passed
+    // Extend Nodefony itself if only one argument is passed
     if (i === length) {
       target = this;
       i--;
     }
     for (; i < length; i++) {
       // Only deal with non-null/undefined values
-      if ((options = arguments[i]) !== null) {
+      if ((options = arguments[i]) != null) {
         // Extend the base object
         for (name in options) {
-          src = target[name];
           copy = options[name];
+          // Prevent Object.prototype pollution
           // Prevent never-ending loop
-          if (target === copy) {
+          if (name === "__proto__" || target === copy) {
             continue;
           }
           // Recurse if we're merging plain objects or arrays
-          let bool = this.typeOf(copy);
-          if (deep && copy && (bool === "object" ||
-              (copyIsArray = (bool === "array")))) {
-            if (copyIsArray) {
-              copyIsArray = false;
-              clone = src && bool === "array" ? src : [];
+          if (deep && copy && (this.isPlainObject(copy) ||
+              (copyIsArray = Array.isArray(copy)))) {
+            src = target[name];
+            // Ensure proper type for the source value
+            if (copyIsArray && !Array.isArray(src)) {
+              clone = [];
+            } else if (!copyIsArray && !this.isPlainObject(src)) {
+              clone = {};
             } else {
-              clone = src && bool === "object" ? src : {};
+              clone = src;
             }
+            copyIsArray = false;
             // Never move original objects, clone them
             target[name] = this.extend(deep, clone, copy);
             // Don't bring in undefined values
@@ -318,13 +326,12 @@ class Nodefony {
    *  @param {Function} closure
    *
    */
-  register(name, closure) {
+  register (name, closure) {
     if (typeof closure === "function") {
       // exec closure
       return this[name] = closure(this, name);
-    } else {
-      return this[name] = closure;
     }
+    return this[name] = closure;
   }
 
   /**
@@ -334,11 +341,11 @@ class Nodefony {
    *  @param {Function} closure
    *
    */
-  registerBundle(name, closure) {
+  registerBundle (name, closure) {
     if (typeof closure === "function") {
       return this.bundles[name] = closure();
     }
-    throw new Error("Register bundle : " + name + "  error bundle bad format");
+    throw new Error(`Register bundle : ${name}  error bundle bad format`);
   }
 
   /**
@@ -348,11 +355,11 @@ class Nodefony {
    *  @param {Function} closure
    *
    */
-  registerFixture(name, closure) {
+  registerFixture (name, closure) {
     if (typeof closure === "function") {
       return closure();
     }
-    throw new Error("Register fixtures : " + name + "  error fixtures bad format");
+    throw new Error(`Register fixtures : ${name}  error fixtures bad format`);
   }
 
   /**
@@ -362,37 +369,39 @@ class Nodefony {
    *  @param {Function} closure
    *
    */
-  registerCommand(name, closure) {
+  registerCommand (name, closure) {
     if (typeof closure === "function") {
       return closure();
     }
-    throw new Error("Register commands : " + name + "  error commands bad format");
+    throw new Error(`Register commands : ${name}  error commands bad format`);
   }
 
-  registerFactory(name, closure) {
+  registerFactory (name, closure) {
     if (typeof closure === "function") {
       return nodefony.security.factories[name] = closure();
     }
-    throw new Error("Register Factory : " + name + "  Error Factory bad format");
+    throw new Error(`Register Factory : ${name}  Error Factory bad format`);
   }
-  registerToken(name, closure) {
+
+  registerToken (name, closure) {
     if (typeof closure === "function") {
       return nodefony.security.tokens[name] = closure();
     }
-    throw new Error("Register Token : " + name + "  Error Token bad format");
+    throw new Error(`Register Token : ${name}  Error Token bad format`);
   }
-  registerProvider(name, closure) {
+
+  registerProvider (name, closure) {
     if (typeof closure === "function") {
       return nodefony.security.providers[name] = closure();
     }
-    throw new Error("Register Provider : " + name + "  Error Provider bad format");
+    throw new Error(`Register Provider : ${name}  Error Provider bad format`);
   }
 
-  getVersion() {
+  getVersion () {
     return require(path.resolve(__dirname, "package.json")).version;
   }
 
-  isNodefonyTrunk(cwd = path.resolve(".")) {
+  isNodefonyTrunk (cwd = path.resolve(".")) {
     try {
       try {
         this.kernelConfigPath = path.resolve(cwd, "config", "config.js");
@@ -422,22 +431,36 @@ class Nodefony {
     }
   }
 
-  loadAppKernel(cwd = path.resolve(".")) {
+  loadAppKernel (cwd = path.resolve("."), detectError = false) {
     try {
-      return this.appKernel = require(path.resolve(cwd, "app", "appKernel.js"));
+      const detectpath = path.resolve(cwd, "app", "appKernel.js");
+      try {
+        fs.lstatSync(detectpath);
+      } catch (e) {
+        if (detectError) {
+          console.error(e);
+          throw e;
+        }
+        return null;
+      }
+      return this.appKernel = require(detectpath);
     } catch (e) {
+      if (e.message === "Class extends value undefined is not a constructor or null") {
+        return null;
+      }
+      console.trace(e);
       return null;
     }
   }
 
-  isElectronContext() {
+  isElectronContext () {
     if (this.versions.electron) {
-      return require('electron');
+      return require("electron");
     }
     return false;
   }
 
-  checkYarn() {
+  checkYarn () {
     try {
       return require("yarn");
     } catch (e) {
@@ -445,7 +468,7 @@ class Nodefony {
     }
   }
 
-  checkNpm() {
+  checkNpm () {
     try {
       return require("npm");
     } catch (e) {
@@ -453,7 +476,7 @@ class Nodefony {
     }
   }
 
-  checkYarnVersion() {
+  checkYarnVersion () {
     let res = null;
     try {
       res = execSync("yarn -v", {
@@ -468,7 +491,7 @@ class Nodefony {
     }
   }
 
-  checkNpmVersion() {
+  checkNpmVersion () {
     let res = null;
     try {
       res = execSync("npm -v", {
@@ -483,31 +506,32 @@ class Nodefony {
     }
   }
 
-  manageCache(cli) {
+  manageCache (cli) {
     if (this.isTrunk) {
-      let cacheLink = path.resolve("tmp", "assestLink");
+      const cacheLink = path.resolve("tmp", "assestLink");
       if (fs.existsSync(cacheLink)) {
         if (cli && cli.logger && cli.debug) {
-          cli.logger("DELETE TMP LINK :" + cacheLink, "DEBUG");
+          cli.logger(`DELETE TMP LINK :${cacheLink}`, "DEBUG");
         }
         shell.rm("-Rf", this.cacheLink);
       }
-      let cacheWebpack = path.resolve("tmp", "webpack");
+      const cacheWebpack = path.resolve("tmp", "webpack");
       if (fs.existsSync(cacheWebpack)) {
         if (cli && cli.logger && cli.debug) {
-          cli.logger("DELETE TMP :" + cacheWebpack, "DEBUG");
+          cli.logger(`DELETE TMP :${cacheWebpack}`, "DEBUG");
         }
         shell.rm("-Rf", cacheWebpack);
       }
     }
   }
 
-  showHelp(cli) {
+  showHelp (cli) {
     // Servers
     cli.setTitleHelp(`${cli.clc.cyan("Servers")}`);
     cli.setHelp("", "dev", "Run Nodefony Development Server");
-    cli.setHelp("", "preprod", "Run Nodefony Preprod Server ( Usefull to check Clusters Node )");
+    cli.setHelp("", "preprod", "Run Nodefony Preprod Server ( Usefull to check Clusters Node use os.cpus().length )");
     cli.setHelp("", "prod", "Run Nodefony Production Server ( PM2 mode )");
+    cli.setHelp("", "start", "Run Nodefony Production Server before transpile for prodution ( dump + PM2 mode ) ");
     cli.setTitleHelp(cli.clc.cyan("PM2 Process Manager 2"));
     cli.setHelp("", "stop [name]", "Stop Production Project");
     cli.setHelp("", "reload [name]", "Reload Production Project");
@@ -524,16 +548,16 @@ class Nodefony {
     // nodefony
     cli.setTitleHelp(cli.clc.cyan("nodefony"));
     cli.setHelp("", "create [-i] name [path]", "Create New Nodefony Project");
-    cli.setHelp("", "build", "Build Nodefony Framework");
-    cli.setHelp("", "rebuild", "Rebuild Nodefony Framework (Recompilation when node version change )");
-    cli.setHelp("", "install", "Install Nodefony Project");
-    cli.setHelp("", "certificates", `Generate HTTPS Certificates  'Change default openssl configuration in config/openssl'`);
-    //cli.setHelp("", "dependencies", "List Project dependencies");
+    cli.setHelp("", "build [sync|migrate]", "Build Nodefony Framework ,transpile, certificats, skeleton , install (default orm migrate)");
+    cli.setHelp("", "install [sync|migrate]", "Install Nodefony Project transpile, sync or migrate Orm (default orm migrate)");
+    cli.setHelp("", "rebuild", "Rebuild Nodefony Framework in production (Usefull when node version change )");
+    cli.setHelp("", "certificates", "Generate HTTPS Certificates  'Change default openssl configuration in config/openssl'");
+    // cli.setHelp("", "dependencies", "List Project dependencies");
     cli.setHelp("", "outdated", "List Project dependencies outdated");
     cli.setHelp("", "version", "Get Project Version");
   }
 
-  async start(cmd, args, cli, options = {}) {
+  async start (cmd, args, cli, options = {}) {
     if (cmd !== "preprod" && cluster.isWorker) {
       cmd = "production";
     }
@@ -548,7 +572,11 @@ class Nodefony {
       process.env.MODE_START = "NODEFONY_DEV";
       cli.setType("SERVER");
       const kernel = new nodefony.appKernel(environment, cli, options);
-      return await kernel.start();
+      return await kernel.start()
+        .catch((e) => {
+          cli.log(e, "ERROR");
+          throw e;
+        });
     case "preprod":
     case "preproduction":
       cli.keepAlive = true;
@@ -556,26 +584,67 @@ class Nodefony {
       environment = "prod";
       process.env.MODE_START = "NODEFONY";
       cli.setType("SERVER");
-      return this.preProd(environment, cli, options);
+      return this.preProd(environment, cli, options)
+        .catch((e) => {
+          cli.log(e, "ERROR");
+          throw e;
+        });
     case "production":
     case "prod":
     case "start":
     case "pm2":
-      cli.keepAlive = true;
-      environment = "prod";
-      if (process.env.MODE_START && process.env.MODE_START === "PM2") {
-        cli.setType("SERVER");
-        const kernel = new nodefony.appKernel(environment, cli, options);
-        return await kernel.start();
-      } else {
-        let options = cli.commander.opts();
-        if (options.dump) {
-          await cli.setCommand("webpack:dump");
+      try {
+        cli.keepAlive = true;
+        environment = "prod";
+        if (process.env.MODE_START && process.env.MODE_START === "PM2") {
+          cli.setType("SERVER");
+          const kernel = new nodefony.appKernel(environment, cli, options);
+          return await kernel.start()
+            .catch(async (e) => {
+              cli.log(e, "ERROR");
+              cli.log("terminate code 1");
+              await cli.terminate(1);
+              throw e;
+            });
+        } else {
+          const options = cli.commander.opts();
+          if (options.dump && !(cmd === "prod" || cmd === "production" || cmd === "pm2")) {
+            await cli.setCommand("webpack:dump");
+          }
+          cli.setType("SERVER");
+          this.manageCache(cli);
+          process.env.MODE_START = "PM2_START";
+          return await this.pm2Start(cli, options)
+            .then((deamon) => {
+              if (deamon) {
+                cli.logger(`DAEMONIZE Process
+                      --no-daemon  if don't want DAEMONIZE  (Usefull for docker)`);
+                return pm2.disconnect(() => {
+                  cli.log("pm2.disconnect");
+                  cli.log("terminate code 0");
+                  return cli.terminate(0);
+                });
+              }
+              cli.log("NO DAEMONIZE");
+            })
+            .catch((e) => {
+              cli.log(e, "ERROR");
+              console.trace(e);
+              return pm2.disconnect(() => {
+                cli.log("pm2.disconnect");
+                cli.log("terminate code 1");
+                return cli.terminate(1);
+
+                /* pm2.killDaemon(() => {
+                    cli.logger(`pm2 killDaemon `, "ERROR");
+                    cli.log(`terminate code 1`)
+                  })*/
+              });
+            });
         }
-        cli.setType("SERVER");
-        this.manageCache(cli);
-        process.env.MODE_START = "PM2_START";
-        return this.pm2Start(cli, options);
+      } catch (e) {
+        // console.error(e)
+        throw e;
       }
       break;
     case "stop":
@@ -583,14 +652,16 @@ class Nodefony {
       if (args.length) {
         name = args[0];
       }
-      pm2.stop(name, (error, proc) => {
+      return pm2.stop(name, (error, proc) => {
         if (error) {
           cli.logger(error, "ERROR");
           cli.terminate(-1);
         }
         cli.logger(`PM2 Stop Project  ${name}`);
         this.tablePm2(cli, proc);
-        cli.terminate(0);
+        return pm2.disconnect(() => {
+          cli.terminate(0);
+        });
       });
       break;
     case "reload":
@@ -598,14 +669,14 @@ class Nodefony {
       if (args.length) {
         name = args[0];
       }
-      pm2.reload(name, (error, proc) => {
+      return pm2.reload(name, (error, proc) => {
         if (error) {
           cli.logger(error, "ERROR");
           return cli.terminate(-1);
         }
         cli.logger(`PM2 reload Project  ${name}`);
         this.tablePm2(cli, proc);
-        return cli.terminate(0);
+        return pm2.disconnect(() => cli.terminate(0));
       });
       break;
     case "restart":
@@ -613,14 +684,14 @@ class Nodefony {
       if (args.length) {
         name = args[0];
       }
-      pm2.restart(name, (error, proc) => {
+      return pm2.restart(name, (error, proc) => {
         if (error) {
           cli.logger(error, "ERROR");
           return cli.terminate(-1);
         }
         cli.logger(`PM2 restart Project  ${name}`);
         this.tablePm2(cli, proc);
-        return cli.terminate(0);
+        return pm2.disconnect(() => cli.terminate(0));
       });
       break;
     case "delete":
@@ -628,32 +699,33 @@ class Nodefony {
       if (args.length) {
         name = args[0];
       }
-      pm2.delete(name, (error, proc) => {
+      return pm2.delete(name, (error, proc) => {
         if (error) {
           cli.logger(error, "ERROR");
           return cli.terminate(-1);
         }
         cli.logger(`PM2 delete Project  ${name}`);
         this.tablePm2(cli, proc);
-        return cli.terminate(0);
+        return pm2.disconnect(() => cli.terminate(0));
       });
       break;
     case "kill":
       cli.keepAlive = true;
       return new Promise(async (resolve, reject) => {
-        const util = require('node:util');
-        const exec = util.promisify(require('node:child_process').exec);
-        let ret = null
+        const util = require("node:util");
+        const exec = util.promisify(require("node:child_process").exec);
+        let ret = null;
         try {
           const {
             stdout,
             stderr
-          } = await exec('npx pm2 kill');
+          } = await exec("npx pm2 kill");
           if (stderr) {
             cli.log(`Kill PM2 MANAGER ${stderr}`, "WARNING");
           } else {
             cli.log(`Kill PM2 MANAGER success ${stdout}`);
-            ret = 0
+            ret = 0;
+            return resolve(process.exit(ret));
           }
         } catch (e) {
           cli.log(`Kill PM2 MANAGER ${e}`, "ERROR");
@@ -662,12 +734,12 @@ class Nodefony {
           const {
             stdout,
             stderr
-          } = await exec('pkill pm2');
+          } = await exec("pkill pm2");
           if (stderr) {
             cli.log(`pkill pm2 ${stderr}`, "WARNING");
           } else {
             cli.log(`pkill pm2 success ${stdout}`);
-            ret = 0
+            ret = 0;
           }
         } catch (e) {
           cli.log(`pkill pm2 ${e}`, "WARNING");
@@ -676,12 +748,12 @@ class Nodefony {
           const {
             stdout,
             stderr
-          } = await exec('killall pm2');
+          } = await exec("killall pm2");
           if (stderr) {
             cli.log(`killall pm2  ${stderr}`, "WARNING");
           } else {
             cli.log(`killall pm2 success ${stdout}`);
-            ret = 0
+            ret = 0;
           }
         } catch (e) {
           cli.log(`killall pm2 ${e}`, "WARNING");
@@ -690,73 +762,17 @@ class Nodefony {
           return resolve(process.exit(ret));
         }
         return resolve(process.exit(-1));
-        //try {
-        /*let res = await pm2.killDaemon((err, proc) => {
-          console.log("passsssss")
-          if (err) {
-            cli.logger(err, "ERROR");
-            pm2.disconnect()
-            process.nextTick(() => {
-              return reject(cli.terminate(-1));
-            })
-          }
-        })*/
-        /*res = pm2.disconnect(() => {
-          cli.logger(`Kill PM2 MANAGER success `);
-          process.nextTick(() => {
-            return resolve(process.exit(0));
-          })
-          console.log("pass")
-        })*/
-        /*return pm2.killDaemon((error, proc) => {
-          console.log("passss killDaemon")
-          if (error) {
-            cli.logger(error, "ERROR");
-            pm2.disconnect()
-            process.nextTick(() => {
-              return reject(cli.terminate(-1));
-            })
-          }
-          cli.logger(`Kill PM2 MANAGER success :  ${proc.success}`);
-          pm2.disconnect()
-          process.nextTick(() => {
-            return resolve(process.exit(0));
-          })*/
-        /*return pm2.list((error, processDescriptionList) => {
-          if (error) {
-            cli.logger(error, "ERROR");
-            pm2.disconnect()
-            process.nextTick(() => {
-              return reject(process.exit(-1));
-            })
-          }
-          this.tablePm2(cli, processDescriptionList);
-          pm2.disconnect()
-          process.nextTick(() => {
-            return resolve(process.exit(0));
-          })
-        });*/
-        //});
-        //} catch (e) {
-        //  pm2.disconnect()
-        //  cli.log(e)
-        //  return reject(cli.terminate(-1));
-        //}
-      })
+      });
     case "status":
     case "list":
       cli.keepAlive = true;
-      pm2.list((error, processDescriptionList) => {
+      return pm2.list((error, processDescriptionList) => {
         if (error) {
           cli.logger(error, "ERROR");
           return cli.terminate(-1);
         }
         this.tablePm2(cli, processDescriptionList);
-        pm2.disconnect(() => {
-          process.nextTick(() => {
-            return process.exit(0);
-          })
-        })
+        return pm2.disconnect(() => pm2.disconnect(() => cli.terminate(0)));
       });
       break;
     case "log":
@@ -781,14 +797,14 @@ class Nodefony {
       break;
     case "clean-log":
       cli.keepAlive = true;
-      pm2.flush((error, result) => {
+      return pm2.flush((error, result) => {
         if (error) {
           cli.logger(error, "ERROR");
           return cli.terminate(-1);
         }
         cli.logger(`clean log ${nodefony.projectName}`);
         this.tablePm2(cli, result);
-        return process.exit(0);
+        return pm2.disconnect(() => cli.terminate(0));
       });
       break;
     case "pm2-logrotate":
@@ -801,19 +817,20 @@ class Nodefony {
         env: process.env,
         stdio: "inherit"
       }).then((code) => {
-        cli.log(`[PM2] Init System found To setup the Startup Script, copy/paste the previous command :)`);
+        cli.log("[PM2] Init System found To setup the Startup Script, copy/paste the previous command :)");
         return code;
-      }).catch(e => {
-        cli.log(e, "ERROR");
-      });
+      })
+        .catch((e) => {
+          cli.log(e, "ERROR");
+        });
     case "pm2-unstartup":
       return cli.npm(["run", "pm2", "unstartup"]);
     case "outdated":
       return cli.setCommand("nodefony:outdated");
     case "test":
       return cli.setCommand("unitest:launch:all");
-      //case "dependencies":
-      //return cli.setCommand("nodefony:bundles:dependencies");
+      // case "dependencies":
+      // return cli.setCommand("nodefony:bundles:dependencies");
     default:
       if (cli.kernel) {
         return await cli.kernel.matchCommand()
@@ -827,7 +844,7 @@ class Nodefony {
           })
           .catch((error) => {
             throw error;
-            //this.logger(error, "ERROR", `COMMAND`);
+            // this.logger(error, "ERROR", `COMMAND`);
           });
       }
       if (this.appKernel) {
@@ -835,24 +852,29 @@ class Nodefony {
         cli.setType("CONSOLE");
         process.env.MODE_START = "NODEFONY_CONSOLE";
         this.manageCache(cli);
-        let kernel = new this.appKernel(environment, cli, options);
-        return await kernel.start()
-          .catch(e => {
-            throw e;
-          });
+        try {
+          const kernel = new this.appKernel(environment, cli, options);
+          return await kernel.start()
+            .catch((e) => {
+              throw e;
+            });
+        } catch (e) {
+          console.error(e);
+          throw e;
+        }
       }
-      if (cli.commander.hasOwnProperty('help')) {
+      if (cli.commander.hasOwnProperty("help")) {
         cli.clear();
         cli.showHelp();
         return Promise.resolve();
       }
-      let error = new Error("No nodefony trunk detected !");
+      const error = new Error("No nodefony trunk detected !");
       throw error;
     }
   }
 
-  tablePm2(cli, apps) {
-    //console.log(apps)
+  tablePm2 (cli, apps) {
+    // console.log(apps)
     let table = null;
     table = cli.displayTable([], {
       head: [
@@ -867,16 +889,16 @@ class Nodefony {
         cli.clc.blue("memory"),
         cli.clc.blue("user"),
         cli.clc.blue("watching")
-      ],
-      //colWidths: [30, 15, 20, 15]
+      ]
+      // colWidths: [30, 15, 20, 15]
     });
     apps.forEach((ele) => {
-      //console.log(ele.pm2_env)
-      //console.log(ele)
+      // console.log(ele.pm2_env)
+      // console.log(ele)
       let cpu = "-";
       let memory = "-";
       if (ele.monit) {
-        cpu = ele.monit.cpu + "%";
+        cpu = `${ele.monit.cpu}%`;
         memory = nodefony.cli.niceBytes(ele.monit.memory);
       }
       let exec_mode = "-";
@@ -933,50 +955,53 @@ class Nodefony {
   /*
    * PM2
    */
-  pm2Start(cli, options) {
+  pm2Start (cli, options) {
     return new Promise((resolve, reject) => {
-      this.setPm2Config();
-      if (!this.pm2Config) {
-        this.pm2Config = this.kernelConfig.system.PM2;
-        this.pm2Config.apps[0].script = process.argv[1] || "nodefony";
-        this.pm2Config.apps[0].args = "pm2";
-        this.pm2Config.apps[0].env = {
-          NODE_ENV: "production",
-          MODE_START: "PM2"
-        };
-      }
-      if (!this.pm2Config.apps[0].name) {
-        this.pm2Config.apps[0].name = this.projectPackage.name || this.projectName;
+      try {
+        this.setPm2Config();
+        if (!this.pm2Config) {
+          this.pm2Config = this.kernelConfig.system.PM2;
+          this.pm2Config.apps[0].script = process.argv[1] || "nodefony";
+          this.pm2Config.apps[0].args = "pm2";
+          this.pm2Config.apps[0].env = {
+            NODE_ENV: "production",
+            MODE_START: "PM2"
+          };
+        }
+        if (!this.pm2Config.apps[0].name) {
+          this.pm2Config.apps[0].name = this.projectPackage.name || this.projectName;
+        }
+        this.pm2Config.apps[0].vizion = false;
+      } catch (e) {
+        return reject(e);
       }
-      this.pm2Config.apps[0].vizion = false;
       pm2.connect((err) => {
         if (err) {
           cli.logger(err, "ERROR");
-          cli.terminate(1);
-          return;
+          return reject(err);
         }
         console.log(util.inspect(this.pm2Config, {
           depth: 10
         }));
-        pm2.start(this.pm2Config, (err /*, apps*/ ) => {
+        pm2.start(this.pm2Config, (err /* , apps*/) => {
           if (err) {
             cli.logger(err.stack || err, "ERROR");
-            reject(err);
-            cli.terminate(1);
+            return reject(err);
           }
-          process.nextTick(() => {
+          cli.logger("PM2 started");
+          process.nextTick(async () => {
             try {
               pm2.list((err, processDescriptionList) => {
+                cli.logger("LIST PROCESS PM2");
                 if (err) {
-                  console.error(err);
+                  cli.logger(err, "WARNING");
                 }
                 this.tablePm2(cli, processDescriptionList);
-                cli.logger(`SAVING process`);
-                //process.env.PWD = process.cwd();
                 pm2.dump((err, result) => {
                   if (err) {
-                    cli.logger(err, "ERROR");
+                    cli.logger(err, "WARNING");
                   }
+                  cli.logger("PM2 SAVING process");
                   if (result.success) {
                     cli.logger(`${process.platform} PM2 process saved `);
                   }
@@ -1008,17 +1033,11 @@ Examples with pm2 native tools :
 $ npx pm2 monit
 $ npx pm2 --lines 1000 logs
                     `);
-                  //resolve(pm2.disconnect());
-                  if (options.daemon) {
-                    cli.terminate(0);
-                  }
+                  return resolve(options.daemon);
                 });
               });
             } catch (e) {
-              cli.logger(e, "ERROR");
-              reject(e);
-              resolve(pm2.disconnect());
-              cli.terminate(1);
+              return reject(e);
             }
           });
         });
@@ -1026,26 +1045,26 @@ $ npx pm2 --lines 1000 logs
     });
   }
 
-  async preProd(environment, cli, options) {
-    const instances = require('os').cpus().length;
+  async preProd (environment, cli, options) {
+    const instances = require("os").cpus().length;
     if (cluster.isMaster) {
       for (let i = 0; i < instances; i++) {
         cluster.fork();
       }
-      cluster.on('disconnect', function ( /*worker*/ ) {
-        console.error('disconnect!');
+      cluster.on("disconnect", (/* worker*/) => {
+        console.error("disconnect!");
       });
-      cluster.on('fork', (worker) => {
-        let wid = worker.id;
-        worker.on('message', (msg) => {
+      cluster.on("fork", (worker) => {
+        const wid = worker.id;
+        worker.on("message", (msg) => {
           if (msg && msg.worker === wid) {
             return;
           }
-          Object.keys(cluster.workers).forEach(function (id) {
+          Object.keys(cluster.workers).forEach((id) => {
             if (id !== wid) {
-              //console.log("CLUSTER SEND FROM  "+ wid + " to " + id)
+              // console.log("CLUSTER SEND FROM  "+ wid + " to " + id)
               cluster.workers[id].send(nodefony.extend(msg, {
-                worker: wid,
+                worker: wid
               }));
             }
           });
@@ -1053,7 +1072,11 @@ $ npx pm2 --lines 1000 logs
       });
     } else {
       const kernel = new nodefony.appKernel(environment, cli, options);
-      return await kernel.start();
+      return await kernel.start()
+        .catch((e) => {
+          cli.log(e, "ERROR");
+          throw e;
+        });
     }
   }
 }