qcobjects-cli 2.4.66 → 2.5.104-beta

package/src/{org.quickcorp.qcobjects.api.client_services.js → org.quickcorp.qcobjects.api.client_services.ts}

@@ -29,43 +29,57 @@
 /*eslint no-mixed-operators: "off"*/
 /*eslint no-undef: "off"*/
 "use strict";
-Package("org.quickcorp.qcobjects.api.client_services", [
 
-  class QuickCorpCloud extends Service {
-    constructor ({
-      name= "quickcorp_cloud",
-      external= true,
-      useHTTP2=true,
-      cached= false,
-      method= "post",
-      headers= {
-        "origin": "localhost",
-        "content-type": "application/json"
-      },
-      basePath= "https://cloud.quickcorp.org/",
-      url= "",
-      withCredentials= false
-    }) {
-      super(...arguments);
+const {Package, Service, logger} = require("qcobjects");
 
-    }
+export class QuickCorpCloud extends Service {
+  constructor ({
+    name= "quickcorp_cloud",
+    external= true,
+    useHTTP2=true,
+    cached= false,
+    method= "post",
+    headers= {
+      "origin": "localhost",
+      "content-type": "application/json"
+    },
+    basePath= "https://cloud.quickcorp.org/",
+    url= "",
+    withCredentials= false
+  }) {
+    super({
+      name,
+      external,
+      useHTTP2,
+      cached,
+      method,
+      headers,
+      basePath,
+      url,
+      withCredentials
+    });
 
-    _new_(o) {
-      // service instantiated
-      this.headers["authorization"] = "Basic token";
-      this.url = this.basePath + o.apiMethod;
-      this.data = o.data;
-    }
-    
-    done(service,standardResponse) {
-      // service loaded
-      logger.debug(standardResponse);
-    }
+  }
 
-    fail(e){
-        logger.debug(e);
-    }
+  _new_(o:any) {
+    // service instantiated
+    this.headers["authorization"] = "Basic token";
+    this.url = this.basePath + o.apiMethod;
+    this.data = o.data;
+  }
+  
+  done(service:any,standardResponse:any) {
+    // service loaded
+    logger.debug(standardResponse);
+  }
 
+  fail(e:any){
+      logger.debug(e);
   }
 
+}
+
+Package("org.quickcorp.qcobjects.api.client_services", [
+QuickCorpCloud
 ]);
+

package/src/org.quickcorp.qcobjects.cli.ts

@@ -0,0 +1,504 @@
+/**
+ * QCObjects CLI 2.4.x
+ * ________________
+ *
+ * Author: Jean Machuca <correojean@gmail.com>
+ *
+ * Cross Browser Javascript Framework for MVC Patterns
+ * QuickCorp/QCObjects is licensed under the
+ * GNU Lesser General Public License v3.0
+ * [LICENSE] (https://github.com/QuickCorp/QCObjects/blob/master/LICENSE.txt)
+ *
+ * Permissions of this copyleft license are conditioned on making available
+ * complete source code of licensed works and modifications under the same
+ * license or the GNU GPLv3. Copyright and license notices must be preserved.
+ * Contributors provide an express grant of patent rights. However, a larger
+ * work using the licensed work through interfaces provided by the licensed
+ * work may be distributed under different terms and without source code for
+ * the larger work.
+ *
+ * Copyright (C) 2015 Jean Machuca,<correojean@gmail.com>
+ *
+ * Everyone is permitted to copy and distribute verbatim copies of this
+ * license document, but changing it is not allowed.
+*/
+/*eslint no-unused-vars: "off"*/
+/*eslint no-redeclare: "off"*/
+/*eslint no-empty: "off"*/
+/*eslint strict: "off"*/
+/*eslint no-mixed-operators: "off"*/
+/*eslint no-undef: "off"*/
+"use strict";
+const fs = require("fs");
+const path = require("path");
+const templatePwaPath = path.resolve(__dirname, "./templates/pwa/") + "/";
+const { exec, execSync } = require("child_process");
+
+require ("qcobjects");
+
+const { CONFIG, findPackageNodePath, logger, Package, InheritClass, New, serviceLoader, global, Service, Component } = require("qcobjects");
+
+CONFIG.set("node_modules_path", "./node_modules/");
+CONFIG.set("qcobjectsnewapp_path", CONFIG.get("node_modules_path") + "/qcobjectsnewapp");
+
+export * as EnterpriseCommands from "./org.qcobjects.enterprise.commands";
+import { QCObjectsEnterprise } from "./org.qcobjects.enterprise.commands";
+export * as QuickCorpServices from "./org.quickcorp.qcobjects.api.client_services";
+import {QuickCorpCloud} from "./org.quickcorp.qcobjects.api.client_services";
+export * as customCommands from "./com.qcobjects.cli.commands";
+import { __get_version__, __get_version_string__ } from "./org.quickcorp.qcobjects.defaultsettings";
+
+export const getPluginCommandsList = () => {
+  return global.ClassesList
+  .filter((c: { packageName: string; }) => c.packageName.startsWith("com.qcobjects.cli.commands."))
+  .filter((p: { classFactory: { name: string; }; }) => p.classFactory.name.endsWith("CommandHandler"));
+};
+
+
+export class SwitchCommander extends InheritClass {
+
+  choiceOption = {
+    generateSw: (_appName: boolean, options: { dir: any; }) => {
+      const dirPrefix = options.dir;
+      const switchCommander = this;
+      const appName = (typeof _appName === "undefined" || _appName === true) ? ("MyAppName") : (_appName);
+      switchCommander.generateServiceWorker(appName, dirPrefix)
+        .catch((e: any) => { logger.warn(`An error ocurred while creating service worker: ${e}`); });
+
+    },
+    create: (_appName: boolean, options: { createAmp: any; createPwa: any; createPhp: any; createCustom: any; }) => {
+      const version = __get_version__();
+      const switchCommander = this;
+      const appName = (typeof _appName === "undefined" || _appName === true) ? ("MyAppName") : (_appName);
+
+
+      let appTemplateName;
+
+      if (options.createAmp) {
+        appTemplateName = "qcobjects-ecommerce-amp";
+      } else if (options.createPwa) {
+        appTemplateName = "qcobjectsnewapp";
+      } else if (options.createPhp) {
+        appTemplateName = "qcobjectsnewphp";
+      } else if (options.createCustom) {
+        appTemplateName = options.createCustom;
+      } else {
+        appTemplateName = "qcobjectsnewapp";
+      }
+      CONFIG.set("qcobjectsnewapp_path", CONFIG.get("node_modules_path") + "/" + appTemplateName);
+
+      const _package_json_template_fname = path.resolve(CONFIG.get("qcobjectsnewapp_path", "qcobjectsnewapp"), "./package.json");
+
+      /*          if (!process.platform.toLowerCase().startsWith("win")){
+              _package_json_content = _package_json_content.replace(/(")/g, String.fromCharCode(92)+"\"");
+            }*/
+
+      const createAppCommand = "npm init -y";
+      const _package_json_file = path.resolve(CONFIG.get("projectPath"), "./package.json");
+      logger.debug("_package_json_file: " + _package_json_file);
+      logger.debug(createAppCommand);
+
+      exec(createAppCommand, (err: { message: string | undefined; }) => {
+        if (err) {
+          throw Error(err.message);
+          // eslint-disable-next-line no-unreachable
+          process.exit(1);
+          return;
+        }
+
+        exec(`npm i --save-dev ${appTemplateName}`, () => {
+          const _package_json_template_file = require(_package_json_template_fname);
+          _package_json_template_file.name = appName;
+          _package_json_template_file.version = "1.0.0";
+          _package_json_template_file.repository = {};
+          fs.writeFileSync(_package_json_file, JSON.stringify(_package_json_template_file, null, 4));
+          logger.info("Good! App Templates was installed!");
+
+          console.log(`Starting to copy files from app template ${appTemplateName} to your project...`);
+
+          switchCommander.copyTemplate(path.resolve(findPackageNodePath(appTemplateName), appTemplateName), path.resolve(CONFIG.get("projectPath"), "./"))
+            .then(() => {
+
+              exec("npm uninstall " + appTemplateName + " --save && npm cache verify", (err: { message: string | undefined; }) => {
+                if (err) {
+                  throw Error(err.message);
+                  // eslint-disable-next-line no-unreachable
+                  process.exit(1);
+                  return;
+                }
+
+                /*
+                switchCommander.generateServiceWorker(appName)
+                .then(()=>{
+                  execSync("npm install --save-dev qcobjects-cli ");
+                });
+                */
+                execSync("npm install --save-dev qcobjects-cli ");
+              });
+
+              exec("npm cache verify && npm i ", (err: { message: string | undefined; }) => {
+                if (err) {
+                  throw Error(err.message);
+                  // eslint-disable-next-line no-unreachable
+                  process.exit(1);
+                  return;
+                }
+
+                logger.info("Good! Your application is done. You can play with QCObjects now!");
+
+                logger.info("I will create the SSL certificates now. It may take some time...");
+                exec("qcobjects-createcert", () => {
+                  logger.info("Test certificates generated");
+
+                  const githubService = New(Service);
+                  githubService.url = "https://raw.githubusercontent.com/QuickCorp/QCObjects/main/.gitignore";
+                  githubService.headers = {
+                    Accept: "application/vnd.github+json",
+                    "X-GitHub-Api-Version": "2022-11-28",
+                    "User-Agent": "qcobjects-cli"
+                  };
+                  githubService.done = () => { };
+                  serviceLoader(githubService)
+                    .then(({service}:{service:any}) => {
+                      fs.writeFileSync(path.resolve(CONFIG.get("projectPath"), "./.gitignore"), service.template);
+                      try {
+                        execSync("git init");
+                        logger.debug("Git initialized.");
+                      } catch (e) {
+                        logger.debug("Could not initialize git.");
+                      }
+                    });
+
+                }).stdout.on("data", function (data: any) {
+                  console.log(data);
+                });
+
+              }).stdout.on("data", function (data: any) {
+                console.log(data);
+              });
+
+            })
+            .catch((e: any) => {
+              console.log(e);
+            });
+
+
+        }).stdout.on("data", function (data: any) {
+          console.log(data);
+        });
+
+      }).stdout.on("data", function () {
+        console.log("App generation started...");
+      });
+
+    },
+    publish(_appName: any, _options:any) {
+      logger.debug("publish is not yet implemented");
+    },
+    upgradeToEnterprise(_appName:any, _options:any) {
+      const switchCommander = this;
+      QCObjectsEnterprise.upgrade(switchCommander);
+    }
+  };
+
+  constructor() {
+    super();
+    this.program = require("commander");
+  }
+
+  shellCommands(_shell_commands: any[]) {
+    return new Promise(function (resolve_all, reject_all) {
+      var _promises_set = _shell_commands.map(
+        function (shell_command: any) {
+          return (new Promise(
+            function (resolve, reject) {
+              logger.debug(shell_command);
+              exec(shell_command, (err: any, stdout: unknown, stderr: any) => {
+                if (!err) {
+                  resolve(stdout);
+                } else {
+                  logger.debug(`[FAILED]: ${shell_command}`);
+                  logger.debug(`${stderr}`);
+                  reject(stderr as Error);
+                }
+              }).stdout.on("data", function (data: any) {
+                logger.info(data);
+              });
+            })).catch(e => reject_all(e as Error));
+        }
+      );
+    }).catch(e => console.log(e));
+  }
+
+  fileListRecursive(dir: string) {
+    var instance = this;
+    return (fs.statSync(dir).isDirectory())
+      ? (Array.prototype.concat(...fs.readdirSync(dir).map((f: any) => instance.fileListRecursive(path.join(dir, f))))
+        .filter((f) => {
+          return !f.startsWith(".git")
+            && f.lastIndexOf(".DS_Store") == -1;
+        })
+      )
+      : (dir);
+  }
+
+  register(email: any, phonenumber: any) {
+    return new Promise(function (resolve, reject) {
+      logger.info("I'm going to register your profile on the cloud...");
+      const cloudClient = New(QuickCorpCloud, {
+        apiMethod: "register",
+        data: { email: email, phonenumber: phonenumber }
+      });
+      //        logger.debugEnabled = true;
+      try {
+      } catch (e) {
+        console.log("\u{1F926} Something went wrong \u{1F926} when trying to register you in the cloud");
+        reject(e as Error);
+      }
+
+    });
+  }
+
+  generateServiceWorker(appName: any, dirPrefix = "./") {
+    const writeContent = (component: any) => {
+      const parsedText = component.parseTemplate(component.template);
+      logger.debug("Starting to write the sw file...");
+      fs.writeFile(`${dirPrefix}/sw.js`, parsedText, (err: string | undefined) => {
+        if (err) {
+          throw Error(err);
+        }
+        logger.info("Service Worker Generated");
+        console.log("");
+        console.log("Now simply put:");
+        console.log("CONFIG.set('serviceWorkerURI','/sw.js');");
+        console.log(" In your init.js file ");
+        console.log("");
+        console.log("To start your app in a local server ");
+        console.log("Execute the command: ");
+        console.log("> qcobjects launch <appname>");
+        console.log("");
+      });
+
+    };
+
+
+    class ServiceWorkerComponent extends Component {
+      cached = false;
+      templateURI = "sw.js";
+      basePath = templatePwaPath;
+      name = "sw";
+      tplsource = "default";
+      template = "";
+
+      constructor({name, data}:{name:string, data:any}){
+        super({name, data});
+      }
+
+      done({ request, component }:{request:any, component:any}) {
+        super.done({ request, component });
+        writeContent(component);
+      }
+    }
+
+    return new Promise(() => {
+      var filelist = ["/"].concat(this.fileListRecursive(`${dirPrefix}`));
+      if (typeof dirPrefix !== "undefined" && dirPrefix !== "./" && dirPrefix !== ".") {
+        filelist = filelist.map(f => f.replace(new RegExp(`${dirPrefix}/`), ""));
+      }
+      filelist = filelist.filter(function (fl) { return fl !== "sw.js" && (!fl.startsWith("node_modules/")); });
+      filelist = filelist.filter(fname => !fname.endsWith(".pem"));
+      filelist = filelist.filter(fname => !fname.endsWith(".sh"));
+      filelist = filelist.filter(fname => !(new RegExp("^package(.*).json$")).test(fname));
+      filelist = filelist.filter(fname => !fname.startsWith("."));
+      var fileListString = "\n\t\"" + filelist.join("\",\n\t\"") + "\"";
+      const component = new ServiceWorkerComponent({
+        name: "sw",
+        data: {
+          appName: appName,
+          appVersion: "1.0.0",
+          filelist: fileListString
+        }
+      });
+
+      setTimeout(()=> {
+        component.done({request:null, component});
+      }, 1000);
+
+
+    });
+  }
+
+  copyTemplate(source: any, dest: any) {
+    return new Promise<void>((resolve, reject) => {
+
+      const copyDir = (source: any, dest: any, exclude: string []) => {
+        source = path.resolve(source);
+        dest = path.resolve(dest);
+        const dname = path.basename(source);
+        const dirExcluded = (exclude.includes(dname));
+
+        const isDir = (d: any) => {
+          return (fs.existsSync(d) && fs.statSync(d).isDirectory()) ? (true) : (false);
+        };
+
+        const isFile = (d: any) => {
+          return (fs.existsSync(d) && fs.statSync(d).isFile()) ? (true) : (false);
+        };
+
+        if (isDir(source) && !dirExcluded) {
+          fs.mkdirSync(dest, { recursive: true });
+          const paths = fs.readdirSync(source, { withFileTypes: true });
+          const dirs = paths.filter((d: { isDirectory: () => any; }) => d.isDirectory());
+          const files = paths.filter((f: { isFile: () => any; }) => f.isFile());
+          (  (paths, dirs, files, exclude) => {
+            files.map((f: { name: any; }) => {
+              const sourceFile = path.resolve(source, f.name);
+              const destFile = path.resolve(dest, f.name);
+              const fileExcluded = exclude.includes(f.name);
+              if (isFile(sourceFile) && !fileExcluded) {
+                logger.debug(`[publish:static] Copying files from ${sourceFile} to ${destFile} excluding ${exclude.join(",")}...`);
+                fs.copyFileSync(sourceFile, destFile);
+                logger.debug(`[publish:static] Copying files from ${sourceFile} to ${destFile} excluding ${exclude.join(",")}...DONE!`);
+              }
+            });
+            dirs.map((d: { name: any; }) => {
+              const sourceDir = path.resolve(source, d.name);
+              const destDir = path.resolve(dest, d.name);
+              copyDir(sourceDir, destDir, exclude);
+            });
+          })(paths, dirs, files, exclude);
+        }
+
+      };
+
+      try {
+        const exclude = [
+          "package.json",
+          "node_modules",
+          ".DS_Store"
+        ];
+        logger.info(`[create] Copying files from ${source} to ${dest} excluding ${exclude.join(",")}...`);
+        copyDir(source, dest, (typeof exclude !== "undefined") ? (exclude) : ([]));
+        resolve();
+      } catch (e:any) {
+        logger.warn(`Something went wrong trying to publish static files: ${e.message}`);
+        reject(e as Error);
+      }
+
+    });
+
+  }
+
+  initCommand() {
+    const switchCommander = this;
+    if (process.argv.length > 1) {
+      logger.debug("Installing Commands...");
+
+      switchCommander.program
+        .version(__get_version_string__());
+      switchCommander.program
+        .command("create <appname>")
+        .description("Creates an app with <appname>")
+        .option("--pwa, --create-pwa", "Creates the progressive web app assets")
+        .option("--amp, --create-amp", "Creates the accelerated mobile pages assets")
+        .option("--php, --create-php", "Creates the PWA PHP assets")
+        .option("--custom, --create-custom <templateappname>", "Creates an App from any NPM package template")
+        .option("--tests, --create-tests", "Creates the test suite")
+        .action(function (args: any, options: any) {
+          switchCommander.choiceOption.create.call(switchCommander, args, options);
+        });
+
+
+      try {
+        logger.debug("Loading Plugin Commands...");
+        const importPluginCommands = function (switchCommander: any) {
+          return getPluginCommandsList().map((pluginCommand: { packageName: any; classFactory: any; plugin: any; }) => {
+              try {
+                logger.debug(`Loading plugin ${pluginCommand.packageName}`);
+                const classFactory = pluginCommand.classFactory;
+                pluginCommand.plugin = new classFactory ({ switchCommander: switchCommander });
+              } catch (e) {
+                throw Error(`Something went wrong loading ${pluginCommand.packageName}`);
+              }
+              return pluginCommand;
+            });
+        };
+        importPluginCommands(switchCommander);
+      } catch (e:any) {
+        throw Error(`Something went wrong loading plugins: ${e.message}`);
+      }
+
+      switchCommander.program.command("publish <appname>")
+        .description("Publishes an app with <appname>")
+        .option("--pwa, --create-pwa", "Publishes the progressive web app assets")
+        .option("--amp, --create-amp", "Publishes the accelerated mobile pages assets")
+        .option("--php, --create-php", "Creates the PWA PHP assets")
+        .option("--custom, --create-custom", "Creates an App from any NPM package template")
+        .option("--tests, --create-tests", "Publishes the test suite")
+        .action( (args: any, options: any) => {
+          switchCommander.choiceOption.publish.bind(switchCommander) ( args, options);
+        });
+
+      switchCommander.program.command("upgrade-to-enterprise")
+        .description("Upgrades to QCObjects Enterprise Edition")
+        .action(function (args: any, options: any) {
+          switchCommander.choiceOption.upgradeToEnterprise.call(switchCommander, args, options);
+        });
+      switchCommander.program.command("generate-sw <appname>")
+        .option("-d, --dir <dirPrefix> ", "creates the service worker in a specific dir <dirPrefix>")
+        .description("Generates the service worker <appname>")
+        .action(function (args: any, options: any) {
+          switchCommander.choiceOption.generateSw.call(switchCommander, args, options);
+        });
+      switchCommander.program.command("launch <appname>")
+        .description("Launches the application")
+        .action(function () {
+          logger.info("Launching...");
+          setTimeout(() => {
+            logger.info("Go to the browser and open https://localhost ");
+            logger.info("Press Ctrl-C to stop serving ");
+            exec("qcobjects-server", () => {
+            }).stdout.on("data", function (data: any) {
+              console.log(data);
+            });
+          }, 5000);
+          //          setTimeout(()=>{
+          //            execSync("open -a \"google chrome\" https://localhost");
+          //          },6000);
+
+        });
+
+      switchCommander.program.on("--help", function () {
+        console.log("");
+        console.log("Use:");
+        console.log("  $ qcobjects-cli [command] --help");
+        console.log("  For detailed information of a command ");
+        console.log("");
+        process.exit(0);
+      });
+
+      switchCommander.program.on("command:*", function () {
+        console.error("Invalid command: %s\nSee --help for a list of available commands.", switchCommander.program.args.join(" "));
+        process.exit(1);
+      });
+      switchCommander.program.parse(process.argv);
+    } else {
+      console.log("");
+      console.log("Use:");
+      console.log("  $ qcobjects-cli [command] --help");
+      console.log("  For detailed information of a command ");
+      console.log("");
+      process.exit(0);
+
+    }
+
+  }
+
+}
+
+
+Package("org.quickcorp.qcobjects.cli", [
+
+  SwitchCommander
+]);
+global.SwitchCommander = SwitchCommander;