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

package/kernel/command.es6

@@ -1,6 +1,5 @@
 class Command extends nodefony.Service {
-
-  constructor(name, cli, bundle) {
+  constructor (name, cli, bundle) {
     super(name, cli.container);
     if (bundle) {
       this.bundleName = bundle.name;
@@ -12,24 +11,22 @@ class Command extends nodefony.Service {
     this.optionsTables = this.cli.optionsTables;
   }
 
-  showBanner() {
-    return this.cli.asciify("      " + this.name)
+  showBanner () {
+    return this.cli.asciify(`      ${this.name}`)
       .then((data) => {
         if (this.json) {
           return data;
         }
         this.cli.clear();
-        let color = this.cli.clc.blueBright.bold;
+        const color = this.cli.clc.blueBright.bold;
         console.log(color(data));
         this.cli.blankLine();
         return data;
       })
-      .catch((e) => {
-        return e;
-      });
+      .catch((e) => e);
   }
 
-  logger(pci, severity, msgid, msg) {
+  logger (pci, severity, msgid, msg) {
     try {
       if (!msgid) {
         msgid = `COMMAND ${this.name}`;
@@ -40,39 +37,39 @@ class Command extends nodefony.Service {
     }
   }
 
-  showHelp(help = "") {
-    for (let mytask in this.tasks) {
+  showHelp (help = "") {
+    for (const mytask in this.tasks) {
       this.tasks[mytask].showHelp();
     }
     return help;
   }
 
-  setTask(name, task) {
+  setTask (name, task) {
     try {
       if (task) {
-        let instance = new task(name, this);
+        const instance = new task(name, this);
         if (instance instanceof nodefony.Task) {
           return this.tasks[instance.name] = instance;
         }
-        throw new Error(`Command setTask must be instance of nodefony.Task class`);
+        throw new Error("Command setTask must be instance of nodefony.Task class");
       }
-      throw new Error(`Command setTask must register nodefony.Task class`);
+      throw new Error("Command setTask must register nodefony.Task class");
     } catch (e) {
       throw e;
     }
   }
 
-  getTask(name) {
+  getTask (name) {
     return this.tasks[name];
   }
 
-  setHelp(command, descrption) {
+  setHelp (command, descrption) {
     this.cli.displayTable([
-        ["", this.cli.clc.green(command), descrption]
-      ], this.optionsTables);
+      ["", this.cli.clc.green(command), descrption]
+    ], this.optionsTables);
   }
 
-  terminate(code) {
+  terminate (code) {
     return this.cli.terminate(code);
   }
 }

package/kernel/commands/nodefonyCommand.es6

@@ -1,55 +1,64 @@
-module.exports = nodefony.register.call(nodefony.commands, "nodefony", function () {
-
+// eslint-disable-next-line max-lines-per-function
+module.exports = nodefony.register.call(nodefony.commands, "nodefony", () => {
   class nodefonyCommand extends nodefony.Command {
-
-    constructor(cli, kernel) {
+    constructor (cli, kernel) {
       super("nodefony", cli, kernel);
       this.setTask("bundles", require(path.resolve(__dirname, "tasks", "bundlesTask.es6")));
     }
 
-    showHelp() {
+    showHelp () {
       return super.showHelp();
     }
 
-    async install(cwd) {
+    async install (cwd, args = []/* , interactive = false*/) {
       try {
+        let strategy = null;
+        let force = false;
+        if (!args) {
+          args = [];
+        }
+        if (args.includes("migrate")) {
+          strategy = "migrate";
+        }
+        if (args.includes("sync")) {
+          strategy = "sync";
+        }
+        if (args.includes("force")) {
+          force = true;
+        }
         this.log("INSTALL NODEFONY FRAMEWORK");
-        return await this.displayInfo(cwd);
+        return await this.installOrm(force, strategy)
+          .catch((e) => {
+            throw e;
+          });
+        // return await this.displayInfo(cwd);
       } catch (error) {
         this.log(error, "ERROR");
         throw error;
       }
     }
 
-    async build(cwd) {
-      try {
-        this.log("BUILD NODEFONY FRAMEWORK");
-        await this.installOrm();
-        return this.displayInfo(cwd);
-      } catch (error) {
-        this.log(error, "ERROR");
-        throw error;
-      }
+    build (cwd, args = [], interactive = false) {
+      this.log("BUILD NODEFONY FRAMEWORK");
+      return this.install(cwd, args, interactive);
     }
 
-    async rebuild(cwd) {
+    rebuild (cwd /* args , interactive = false*/) {
       try {
-        //await this.listPackage(cwd);
+        // await this.listPackage(cwd);
         return cwd;
       } catch (e) {
         throw e;
       }
     }
 
-    installOrm(force = false) {
+    installOrm (force = false, strategy = null) {
       this.log("INITIALIZE ORM");
       this.orm = this.cli.kernel.getOrm();
       switch (this.orm) {
       case "sequelize":
-        return this.installSequelize(force)
-          .then(() => {
-            return this.generateSequelizeFixture();
-          }).catch((e) => {
+        return this.installSequelize(force, strategy || this.cli.kernel.getOrmStrategy())
+          .catch((e) => {
             throw e;
           });
       case "mongoose":
@@ -58,49 +67,97 @@ module.exports = nodefony.register.call(nodefony.commands, "nodefony", function
             throw e;
           });
       default:
-        throw new Error(`ORM not defined : $(this.orm)`);
+        throw new Error("ORM not defined : $(this.orm)");
       }
     }
 
-    async installSequelize(force = false) {
+    async installSequelize (force = false, strategy = "migrate") {
       this.log("INITIALIZE SEQUELIZE");
       let command = null;
       let task = null;
+      let res = null;
       try {
         command = this.cli.getCommand("sequelize", "sequelize");
         task = command.getTask("create");
-        await task.database();
+        res = await task.database()
+          .catch((e) => {
+            throw e;
+          });
       } catch (e) {
         this.log(e, "WARNING");
       }
+      if (!force && strategy === "none") {
+        return res;
+      }
       try {
         command = this.cli.getCommand("sequelize", "sequelize");
-        task = command.getTask("sync");
-        return await task.entities(force);
+        // with migrate
+        if (!force && strategy === "migrate") {
+          task = command.getTask("migrate");
+          await task.up()
+            .catch((e) => {
+              throw e;
+            });
+          await task.status()
+            .catch((e) => {
+              throw e;
+            });
+          task = command.getTask("sync");
+          await task.entities({force}, true)
+            .catch((e) => {
+              throw e;
+            });
+          task = command.getTask("seedeers");
+          await task.up()
+            .catch((e) => {
+              throw e;
+            });
+          return await task.status()
+            .catch((e) => {
+              throw e;
+            });
+        }
+        // with sysnc
+        if (strategy === "sync") {
+          task = command.getTask("sync");
+          await task.entities({force}, true)
+            .catch((e) => {
+              throw e;
+            });
+          task = command.getTask("seedeers");
+          await task.up()
+            .catch((e) => {
+              throw e;
+            });
+          return await task.status()
+            .catch((e) => {
+              throw e;
+            });
+        }
       } catch (e) {
         this.log(e, "ERROR");
         throw e;
       }
     }
 
-    async generateSequelizeFixture() {
+    async generateSequelizeFixture () {
       try {
         this.log("Generate Sequelize Fixtures");
-        let command = this.cli.getCommand("users", "users");
-        let task = command.getTask("fixtures");
+        const command = this.cli.getCommand("users", "users");
+        const task = command.getTask("fixtures");
         return await task.default();
       } catch (e) {
         throw e;
       }
     }
 
-    async installMongoose() {
+    async installMongoose () {
       try {
         this.log("INITIALIZE Mongoose");
         this.log("Generate Mongoose Fixtures");
         if (this.kernel.bundles.users) {
-          let command = this.cli.getCommand("users", "users");
-          let task = command.getTask("fixtures");
+          const command = this.cli.getCommand("users", "users");
+          const task = command.getTask("fixtures");
           return await task.default();
         }
         return true;
@@ -109,10 +166,10 @@ module.exports = nodefony.register.call(nodefony.commands, "nodefony", function
       }
     }
 
-    async outdated() {
+    async outdated () {
       try {
         this.log("PACKAGES OUTDATED");
-        let args = [];
+        const args = [];
         let trunk = null;
         if (this.cli.kernel.isCore) {
           trunk = path.resolve(".", "package.json");
@@ -126,47 +183,43 @@ module.exports = nodefony.register.call(nodefony.commands, "nodefony", function
           this.log(`Check Outdated trunk :  ${trunk}`);
           args.push(new nodefony.fileClass(trunk));
         }
-        for (let bundle in this.cli.kernel.bundles) {
+        for (const bundle in this.cli.kernel.bundles) {
           if (nodefony.isCore) {
             this.log(`Check Outdated Bundle :  ${this.cli.kernel.bundles[bundle].name}`);
             args.push(this.cli.kernel.bundles[bundle]);
-          } else {
-            if (!this.cli.kernel.isBundleCore(bundle)) {
-              this.log(`Check Outdated ${this.cli.kernel.bundles[bundle].name}`);
-              args.push(this.cli.kernel.bundles[bundle]);
-            }
+          } else if (!this.cli.kernel.isBundleCore(bundle)) {
+            this.log(`Check Outdated ${this.cli.kernel.bundles[bundle].name}`);
+            args.push(this.cli.kernel.bundles[bundle]);
           }
         }
-        let task = this.getTask("bundles");
+        const task = this.getTask("bundles");
         return await task.outdated.apply(task, args);
       } catch (e) {
         throw e;
       }
     }
 
-    displayInfo(cwd) {
+    displayInfo (cwd) {
       return this.listRouting()
-        .then(() => {
-          return this.matchHomeRoute("/")
-            .then(() => {
-              return cwd
-              /*return this.listPackage(cwd)
+        .then(() => this.matchHomeRoute("/")
+          .then(() => cwd
+
+            /* return this.listPackage(cwd)
                 .then(() => {
                   return cwd;
                 });*/
-            });
-        });
+          ));
     }
 
-    listPackage(cwd) {
+    listPackage (cwd) {
       return this.cli.listPackage(cwd);
     }
 
-    async matchHomeRoute(route) {
+    async matchHomeRoute (route) {
       this.log("ROUTING LIST ");
       try {
-        let command = this.cli.getCommand("router", "framework");
-        let task = command.getTask("display");
+        const command = this.cli.getCommand("router", "framework");
+        const task = command.getTask("display");
         if (task) {
           return await task.match(route || "/");
         }
@@ -176,11 +229,11 @@ module.exports = nodefony.register.call(nodefony.commands, "nodefony", function
       }
     }
 
-    async listRouting() {
+    async listRouting () {
       try {
         this.log("ROUTING LIST ");
-        let command = this.cli.getCommand("router", "framework");
-        let task = command.getTask("display");
+        const command = this.cli.getCommand("router", "framework");
+        const task = command.getTask("display");
         if (task) {
           return await task.routes();
         }

package/kernel/commands/tasks/bundlesTask.es6

@@ -1,11 +1,11 @@
 module.exports = class bundlesTask extends nodefony.Task {
-
-  constructor(name, command) {
+  constructor (name, command) {
     super(name, command);
   }
 
-  showHelp() {
-    /*this.setHelp("nodefony:bundles:listDependencies",
+  showHelp () {
+
+    /* this.setHelp("nodefony:bundles:listDependencies",
       "List Nodefony dependencies"
     );
     this.setHelp("nodefony:bundles:install [environment]",
@@ -13,22 +13,20 @@ module.exports = class bundlesTask extends nodefony.Task {
     );*/
   }
 
-  /*async dependencies() {
+  /* async dependencies() {
     return await this.cli.listPackage(this.kernel.rootDir);
   }*/
 
-  async install(...args) {
+  async install (...args) {
     try {
       for (let i = 0; i < args.length; i++) {
         if (args[i] instanceof nodefony.fileClass || args[i] instanceof nodefony.Bundle) {
           if (this.kernel.isCore) {
-            //mypromise.push(this.cli.installPackage(args[i], this.kernel.environment));
+            // mypromise.push(this.cli.installPackage(args[i], this.kernel.environment));
+            await this.cli.installPackage(args[i], this.kernel.environment);
+          } else if (!this.kernel.isBundleCore(args[i].name)) {
+            // mypromise.push(this.cli.installPackage(args[i], this.kernel.environment));
             await this.cli.installPackage(args[i], this.kernel.environment);
-          } else {
-            if (!this.kernel.isBundleCore(args[i].name)) {
-              //mypromise.push(this.cli.installPackage(args[i], this.kernel.environment));
-              await this.cli.installPackage(args[i], this.kernel.environment);
-            }
           }
         }
       }
@@ -39,26 +37,23 @@ module.exports = class bundlesTask extends nodefony.Task {
     this.log("Install success");
   }
 
-  async outdated(...args) {
+  async outdated (...args) {
     for (let i = 0; i < args.length; i++) {
       if (args[i] instanceof nodefony.fileClass || args[i] instanceof nodefony.Bundle) {
         if (this.kernel.isCore) {
           await this.cli.outdatedPackage(args[i]);
-        } else {
-          if (!this.kernel.isBundleCore(args[i].name)) {
-            await this.cli.outdatedPackage(args[i]);
-          }
+        } else if (!this.kernel.isBundleCore(args[i].name)) {
+          await this.cli.outdatedPackage(args[i]);
         }
       }
     }
   }
 
-  async rebuild(...args) {
+  async rebuild (...args) {
     for (let i = 0; i < args.length; i++) {
       if (args[i] instanceof nodefony.fileClass || args[i] instanceof nodefony.Bundle) {
         await this.cli.rebuildPackage(args[i]);
       }
     }
   }
-
 };