qcobjects-cli 2.4.66 → 2.5.104-beta

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

@@ -0,0 +1,424 @@
+/**
+ * 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";
+
+require ("qcobjects");
+
+const { CONFIG, global, logger, _Crypt, findPackageNodePath, Export } = require("qcobjects");
+
+export const __get_version__ = () => {
+  const path = require("path");
+
+  const absolutePath = path.resolve(__dirname, "./");
+  const package_config = require(path.resolve(process.cwd(), "package.json"));
+  const qcobjects_pkg_config = require("qcobjects/package.json");
+  const qcobjects_sdk_pkg_config = require("qcobjects-sdk/package.json");
+  return {
+    "qcobjects": qcobjects_pkg_config.version,
+    "sdk": qcobjects_sdk_pkg_config.version,
+    "cli": package_config.version
+  };
+};
+
+export const __get_version_string__ = () => {
+  const version = __get_version__();
+  return "QCObjects: v" + version.qcobjects + ", SDK: v" + version.sdk + ", CLI: v" + version.cli;
+};
+
+Export(__get_version__);
+Export(__get_version_string__);
+
+
+const __load_default_settings__ = () => {
+  CONFIG.set("documentRootFileIndex", "index.html");
+  CONFIG.set("projectPath", `${process.cwd()}/`);
+  CONFIG.set("useConfigService", false); // this is only true useful for client web side
+  CONFIG.set("documentRoot", "./");
+  CONFIG.set("serverPortHTTP", 80);
+  CONFIG.set("serverPortHTTPS", 443);
+  CONFIG.set("private-key-pem", "localhost-privkey.pem");
+  CONFIG.set("private-cert-pem", "localhost-cert.pem");
+  CONFIG.set("allowHTTP1", true);
+  CONFIG.set("useTemplate", false);
+  CONFIG.set("domain", "localhost");
+
+
+
+  const setDevMode = (devmode: string) => {
+    if (typeof devmode !== "undefined") {
+      switch (true) {
+        case devmode == "debug":
+          logger.debugEnabled = true;
+          logger.warnEnabled = true;
+          logger.infoEnabled = true;
+          break;
+        case devmode == "warn":
+          logger.debugEnabled = false;
+          logger.warnEnabled = true;
+          logger.infoEnabled = true;
+          break;
+        case devmode == "info":
+          logger.debugEnabled = false;
+          logger.warnEnabled = false;
+          logger.infoEnabled = true;
+          break;
+
+        default:
+          logger.debugEnabled = false;
+          logger.warnEnabled = false;
+          logger.infoEnabled = false;
+          break;
+      }
+    } else {
+      logger.debugEnabled = false;
+      logger.warnEnabled = false;
+      logger.infoEnabled = false;
+    }
+
+  };
+
+  try {
+    var _config = require(CONFIG.get("projectPath") + "config.json");
+    logger.debug("Loading settings from your config.json");
+
+    const _secretKey = (Object.hasOwn(_config, "domain")) ? (_config["domain"]) : ("_secret_");
+
+    if (Object.hasOwn(_config, "__encoded__")) {
+      _config = JSON.parse(_Crypt.decrypt(_config.__encoded__, _secretKey));
+    }
+    for (var k in _config) {
+      CONFIG.set(k, _config[k]);
+    }
+
+    setDevMode(CONFIG.get("devmode", ""));
+
+    if (typeof CONFIG.get("backend") !== "undefined") {
+      global.set("backendAvailable", true);
+
+      if (typeof CONFIG.get("basePath") !== "undefined") {
+        logger.debug(`Changing the current directory: ${process.cwd()}`);
+        try {
+          process.chdir(CONFIG.get("basePath"));
+          logger.debug(`New directory: ${process.cwd()}`);
+        } catch (err: any) {
+          logger.warn(`It was impossible to change the current chdir: ${err}`);
+        }
+      }
+    }
+  } catch (e) {
+    logger.debug(e);
+    logger.debug("Something went wrong trying to load config.json file in your project");
+  }
+
+  (async function () {
+    const path = require("path");
+    const projectPath = CONFIG.get("projectPath", `${process.cwd()}/`);
+    const loadDefaultRoutes = async () => {
+      return await new Promise<void>((resolve, reject) => {
+        const sdkPath = path.resolve(findPackageNodePath("qcobjects-sdk"), "qcobjects-sdk");
+        const qcobjectsPath = path.resolve(findPackageNodePath("qcobjects"), "qcobjects");
+        let backend = CONFIG.get("backend");
+        if (typeof backend === "undefined") {
+          backend = {};
+        }
+        if (typeof backend.routes === "undefined") {
+          backend.routes = [];
+        }
+        backend.routes = backend.routes.concat([{
+          "name": "QCObjects.js",
+          "description": "Redirection of QCObjects.js",
+          "path": "^/QCObjects.js$",
+          "microservice": "com.qcobjects.backend.microservice.static",
+          "redirect_to": path.resolve(qcobjectsPath, "src", "QCObjects.js"),
+          "responseHeaders": {},
+          "cors": {
+            "allow_origins": "*"
+          }
+        },
+        {
+          "name": "QCObjects-SDK.js",
+          "description": "Redirection of QCObjects SDK",
+          "path": "^/js/packages/QCObjects-SDK.js$",
+          "microservice": "com.qcobjects.backend.microservice.static",
+          "redirect_to": path.resolve(sdkPath, "src/QCObjects-SDK.js"),
+          "responseHeaders": {},
+          "cors": {
+            "allow_origins": "*"
+          }
+        },
+        {
+          "name": "QCObjects-SDK Components",
+          "description": "Redirection of QCObjects SDK",
+          "path": "^/qcobjects-sdk/(.*)$",
+          "microservice": "com.qcobjects.backend.microservice.static",
+          "redirect_to": path.resolve(sdkPath, "$1"),
+          "responseHeaders": {},
+          "cors": {
+            "allow_origins": "*"
+          }
+        }
+
+        ]);
+        CONFIG.set("backend", backend);
+        resolve();
+      });
+    };
+    await loadDefaultRoutes();
+  })()
+    .then(() => logger.info("Default routes loaded"))
+    .catch((e: any) => { logger.warn(`An error ocurred loading default settings: ${e}`); });
+
+  (function () {
+    /* Auto Discover dependencies (lib, handlers, commands) */
+    const path = require("path");
+    const fs = require("fs");
+    const projectPath = CONFIG.get("projectPath", `${process.cwd()}/`);
+    logger.debug(`CONFIG.projectPath is set to ${projectPath}`);
+    const findPath = (p: string) => {
+      const packagePath = path.resolve(findPackageNodePath(p), p);
+      return packagePath;
+    };
+
+    const getPackageJSON = (p: string) => {
+      let _json;
+      try {
+        const packagePath = findPath(p);
+        if (typeof packagePath !== "undefined") {
+          _json = JSON.parse(fs.readFileSync(path.resolve(`${packagePath}`, "./package.json")).toString());
+        } else {
+          _json = {};
+        }
+      } catch (e: any) {
+        logger.debug(`It was impossible to get the package.json from ${p}: ${e}`);
+        _json = {};
+      }
+      return _json;
+    };
+
+    const hasKeyword = (() => {
+      let keywords: { [key: string]: string[] } = {};
+      return (p: string, keyword: string) => {
+        if (typeof keywords === "undefined") {
+          keywords = {};
+        }
+        try {
+          if (typeof keywords[p] === "undefined") {
+            keywords[p] = getPackageJSON(p).keywords;
+          }
+        } catch (e) {
+          throw Error(`Something went wrong when trying to get the keywords of ${p}`);
+        }
+        return typeof keywords[p] !== "undefined" && keywords[p].includes(keyword);
+      };
+    })();
+
+    const setBackendValue = (name: string, value: any) => {
+      const backend = CONFIG.get("backend", {});
+      if (typeof value !== "undefined") {
+        backend[name] = value;
+      }
+      CONFIG.set("backend", backend);
+    };
+
+    const dependencies = (() => {
+      let deps: string[] = [];
+      return () => {
+        if (typeof deps === "undefined") {
+          deps = Object.keys(JSON.parse(fs.readFileSync(path.resolve(`${projectPath}`, "./package.json")).toString()).dependencies);
+          setBackendValue("dependencies", deps);
+        }
+        return deps;
+      };
+    })();
+
+    const devDependencies = (() => {
+      let deps: string[] = [];
+      return () => {
+        if (typeof deps === "undefined") {
+          deps = Object.keys(JSON.parse(fs.readFileSync(path.resolve(`${projectPath}`, "./package.json")).toString()).devDependencies);
+          setBackendValue("devDependencies", deps);
+        }
+        return deps;
+      };
+    })();
+
+    const loadLibs = () => {
+      let _ret_;
+      if (CONFIG.get("autodiscover", false) || CONFIG.get("autodiscover_libs", false)) {
+        const libs = dependencies().filter((p) => hasKeyword(p, "qcobjects-lib"));
+        setBackendValue("libs", libs);
+        if (libs.length > 0) {
+          logger.debug(`Plugin Libs found: ${libs.join(",")}`);
+          _ret_ = Promise.all(libs.map((p) => { return require(findPath(p)); })).then(() => logger.info("Libs loaded"));
+        } else {
+          logger.debug("No Plugin Libs found.");
+          _ret_ = Promise.resolve();
+        }
+      } else {
+        logger.debug("To load libs, set autodiscover_libs to true in your config.json");
+        _ret_ = Promise.resolve();
+      }
+      return _ret_;
+    };
+    const loadHandlers = () => {
+      let _ret_;
+      if (CONFIG.get("autodiscover", false) || CONFIG.get("autodiscover_handlers", false)) {
+        const handlers = dependencies().filter((p) => hasKeyword(p, "qcobjects-handler"));
+        setBackendValue("handlers", handlers);
+        if (handlers.length > 0) {
+          logger.debug(`Plugin Handlers found: ${handlers.join(",")}`);
+          _ret_ = Promise.all(handlers.map((p) => { return require(findPath(p)); })).then(() => logger.info("Handlers loaded"));
+        } else {
+          logger.debug("No Plugin Handlers found.");
+          _ret_ = Promise.resolve();
+        }
+      } else {
+        logger.debug("To load handlers, set autodiscover_handlers to true in your config.json");
+        _ret_ = Promise.resolve();
+      }
+      return _ret_;
+    };
+    const loadCommands = () => {
+      let _ret_;
+      logger.debug(`Looking for custom commands as dependencies in: ${projectPath}/package.json`);
+      if (CONFIG.get("autodiscover", false) || CONFIG.get("autodiscover_commands", false)) {
+        const commands = dependencies().filter((p) => hasKeyword(p, "qcobjects-command"));
+        setBackendValue("commands", commands);
+        if (commands.length > 0) {
+          logger.debug(`Plugin Commands found: ${commands.join(",")}`);
+          _ret_ = Promise.all(commands.map((p) => { return require(findPath(p)); })).then(() => logger.info("Commands loaded"));
+        } else {
+          logger.debug("No Plugin Commands found.");
+          _ret_ = Promise.resolve();
+        }
+      } else {
+        logger.debug("To load commands, set autodiscover_commands to true in your config.json");
+        _ret_ = Promise.resolve();
+      }
+      return _ret_;
+    };
+    const loadDevCommands = () => {
+      let _ret_;
+      logger.debug(`Looking for custom commands as dev dependencies in: ${projectPath}/package.json`);
+      if (CONFIG.get("autodiscover", false) || CONFIG.get("autodiscover_commands", false)) {
+        const commands = devDependencies().filter((p) => hasKeyword(p, "qcobjects-command"));
+        setBackendValue("devCommands", commands);
+        if (commands.length > 0) {
+          logger.debug(`Dev Plugin Commands found: ${commands.join(",")}`);
+          _ret_ = Promise.all(commands.map((p) => { return require(findPath(p)); })).then(() => logger.info("Commands loaded"));
+        } else {
+          logger.debug("No Plugin Commands found in dev dependencies.");
+          _ret_ = Promise.resolve();
+        }
+      } else {
+        logger.debug("To load commands, set autodiscover_commands to true in your config.json");
+        _ret_ = Promise.resolve();
+      }
+      return _ret_;
+    };
+
+    if (CONFIG.get("autodiscover", false) ||
+      CONFIG.get("autodiscover_libs", false) ||
+      CONFIG.get("autodiscover_handlers", false) ||
+      CONFIG.get("autodiscover_commands", false)
+    ) {
+      logger.info("Auto discover is enabled");
+    } else if (!CONFIG.get("autodiscover", false)) {
+      logger.info("Auto discover is disabled");
+      logger.debug("To load all dependencies, set autodiscover to true in your config.json");
+    } else {
+      logger.info("Auto discover is disabled");
+    }
+
+    try {
+      logger.debug("Loading Libs...");
+      loadLibs().catch((e: any) => {
+        logger.warn(`An error ocurred loading libs: ${e}`);
+      });
+    } catch (e: any) {
+      throw Error(`Something went wrong trying to load libs: ${e.message}`);
+    }
+    try {
+      logger.debug("Loading Handlers...");
+      loadHandlers().catch((e: any) => {
+        logger.warn(`An error ocurred loading handlers: ${e}`);
+      });
+    } catch (e: any) {
+      throw Error(`Something went wrong trying to load handler: ${e.message}`);
+    }
+    try {
+      logger.debug("Loading Commands...");
+      loadCommands().catch((e: any) => {
+        logger.warn(`An error ocurred loading commands: ${e}`);
+      });
+    } catch (e: any) {
+      throw Error(`Something went wrong trying to load commands: ${e.message}`);
+    }
+    try {
+      logger.debug("Loading Dev Commands...");
+      loadDevCommands().catch((e: any) => {
+        logger.warn(`An error ocurred loading dev commands: ${e}`);
+      });
+    } catch (e: any) {
+      throw Error(`Something went wrong trying to load Dev commands: ${e.message}`);
+    }
+
+    try {
+      const commands = CONFIG.get("backend", { commands: [] }).commands || [];
+      const devCommands = CONFIG.get("backend", { devCommands: [] }).devCommands || [];
+      setBackendValue("plugins", commands.concat(devCommands));
+    } catch (e: any) {
+      throw Error(`Something went wrong trying to load plugins list: ${e.message}`);
+    }
+
+    logger.info("Dependencies loaded");
+
+    process.once("SIGTERM", () => {
+      console.log("\x1b[33m%s\x1b[0m", "Bye bye!");
+      process.exit();
+    });
+  })();
+};
+
+global.__load_default_settings__ = __load_default_settings__;
+global.__load_default_settings__();
+
+const cleanCache = () => {
+  Object.keys(require.cache).forEach((key) => { delete require.cache[key]; });
+};
+
+const __reset_settings__ = () => {
+  cleanCache();
+  global.__load_default_settings__();
+};
+
+global.__reset_settings__ = __reset_settings__;
+

package/src/org.quickcorp.qcobjects.main.file.ts

@@ -0,0 +1,180 @@
+/**
+ * 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 path = require("path");
+const fs = require("fs");
+const mime = require("mime");
+
+const {InheritClass, CONFIG, logger, New, Component, Package} = require("qcobjects");
+
+const absolutePath = path.resolve(__dirname, "./");
+
+class FileDispatcher extends InheritClass {
+  constructor({
+    name = CONFIG.get("documentRootFileIndex"),
+    template = "",
+    templateURI = CONFIG.get("documentRootFileIndex"),
+    headers = {},
+    body = "",
+    filename = "",
+    done
+  }:{
+    name:string, template:string, templateURI:string, headers:any, body:string, filename:string,
+    done:(headers:any, body:any, templateURI?:string,isTemplate?:boolean) => any
+  }) {
+    super({
+      name,
+      template,
+      templateURI,
+      headers,
+      body,
+      filename,
+      done
+    });
+
+    var o = this;
+
+    var scriptname = o.scriptname;
+    this.filename = scriptname;
+    var pathname = (o.pathname !== "") ? (o.pathname + "/") : ("");
+    var appTemplateInstance = this;
+    if (typeof appTemplateInstance.headers === "undefined"){
+      appTemplateInstance.headers = {
+        ":status": 500,
+        "content-type": "text/html"
+      };
+    }
+
+    appTemplateInstance.done = o.done.bind(appTemplateInstance);
+    appTemplateInstance.templateURI = CONFIG.get("documentRoot") + pathname + scriptname;
+    appTemplateInstance.templateURI = appTemplateInstance.templateURI.replace("//", "/");
+
+    if (appTemplateInstance.isTemplate()) {
+      fs.readFile(appTemplateInstance.templateURI, function (err:any, data:any) {
+        logger.debug("reading data from " + appTemplateInstance.templateURI);
+        if (typeof data !== "undefined") {
+          appTemplateInstance.template = data.toString();
+          appTemplateInstance._done();
+        } else {
+          appTemplateInstance.headers = {
+            ":status": 404,
+            "content-type": "text/html"
+          };
+          appTemplateInstance.done(
+            appTemplateInstance.headers,
+            "FILE NOT FOUND", "notfound.html", false);
+          logger.debug("file not found");
+        }
+      });
+    } else {
+      appTemplateInstance.headers[":status"] = 200;
+      appTemplateInstance.headers["content-type"] = mime.getType(appTemplateInstance.templateURI);
+      appTemplateInstance.done(
+        appTemplateInstance.headers,
+        "", appTemplateInstance.templateURI, false);
+    }
+
+    logger.info("FileDispatcher initialized");
+
+  }
+
+  file_extension() {
+    return this.filename.substr(this.filename.indexOf("."));
+  }
+  isTemplate() {
+    return CONFIG.get("useTemplate") && (this.file_extension() == ".html" || this.file_extension() == ".tpl.html");
+  }
+  _done() {
+    var appTemplateInstance = this;
+    const source = appTemplateInstance.template;
+    if (appTemplateInstance.isTemplate()) {
+
+      (New(Component, {
+        name: "static_source",
+        template: source,
+        cached: false,
+        tplsource: "inline",
+        data: {
+          title: "QCObjects"
+        },
+        done({
+          request,
+          component
+        }:{request:any, component:any}) {
+          appTemplateInstance.body = component.parsedAssignmentText;
+          return Promise.resolve({
+            request,
+            component
+          });
+        }
+      }));
+
+    } else {
+      appTemplateInstance.body = source;
+    }
+
+    if ([".png",
+        ".jpg",
+        ".jpeg",
+        ".json",
+        ".html",
+        ".tpl.html",
+        ".css",
+        ".js",
+        ".svg"
+      ].includes(appTemplateInstance.file_extension())) {
+      appTemplateInstance.headers["content-type"] = mime.getType(appTemplateInstance.templateURI);
+      appTemplateInstance.headers["cache-control"] = CONFIG.get("cacheControl", "max-age=31536000");
+      appTemplateInstance.done(
+        appTemplateInstance.headers,
+        appTemplateInstance.body,
+        appTemplateInstance.templateURI,
+        appTemplateInstance.isTemplate());
+    } else {
+      appTemplateInstance.done({
+          ":status": 403,
+          "content-type": "text/plain"
+        },
+        "FORBIDDEN", "notfound.html", false);
+    }
+  }
+  done(headers:any, body:any, templateURI = "", isTemplate = false) {}
+
+}
+
+
+Package("org.quickcorp.qcobjects.main.file", [
+  FileDispatcher
+]);
+
+exports = {
+  FileDispatcher
+};