profoundjs 6.0.0-beta.3 → 6.0.0-beta.7

package/setup/completeInstall.js

@@ -0,0 +1,465 @@
+#!/usr/bin/env node
+
+"use strict";
+
+/*
+
+  * This is NPM run script 'completeInstall'
+
+  * This script is intended to be run by the user at a shell after 'npm install', via 'complete_intall.js'.
+
+  * Prompts for configuration values and other installation options, if necessary, and creates config.js.
+  * Kicks off 'npm run setup' to complete installation.
+
+*/
+
+const child_process = require("child_process");
+const fs = require("fs");
+const minimist = require("minimist");
+const os = require("os");
+const path = require("path");
+const readline = require("readline");
+const iutils = require("./install_utils.js");
+
+const IBMi = os.type() === "OS400";
+
+(async () => {
+  try {
+
+    // Parse arguments.
+    const args = minimist(
+      process.argv.slice(2),
+      {
+        alias: {
+          "h": "help",
+          "c": "configure"
+        },
+        boolean: [
+          "h",
+          "c"
+        ],
+        unknown: function(arg) {
+          console.error("Unknown argument:", arg);
+          process.exit(1);
+        }
+      }
+    );
+
+    // Show help and quit, if requested.
+    if (args["help"]) {
+const HELP = `Usage: node complete_install.js [OPTION]
+-h, --help        Print this help and exit.
+-c, --configure   Prompt for configuration values.
+
+Creates config.js and completes installation.
+If config.js is not present, this script prompts for values and creates it.
+If config.js is already present, installation proceeds silently by default.
+  In this case, --configure can be used to prompt and update config.js first.
+`;
+      console.log(HELP);
+      process.exit(0);
+    }
+
+    // Validate arguments.
+    if (args._.length > 0) {
+      console.error("Unknown argument:", args._[0]);
+      process.exit(1);
+    }
+
+    const deployDir = iutils.getDeployDir();
+    if (!deployDir) {
+      console.error("Can't find deployment directory.");
+      process.exit(1);
+    }
+    const configPath = iutils.getConfigPath();
+    let config = fileExists(configPath) ? require(configPath) : {};
+
+    let downloadStaticFiles;
+    let svrname, autostart, ccsid, nodePath;
+
+    // If config.js doesn't exist, or if --configure is passed, prompt and create/update config.js.
+    if (!fileExists(configPath) || args["configure"] === true) {
+
+      let staticFilesDirectory, port, gitSupport;
+      let profounduiLibrary, connectorLibrary, connectorIASP;
+
+      let defaultStaticDir;
+      if (IBMi) {
+        defaultStaticDir = config.staticFilesDirectory || "/www/profoundui/htdocs"
+        if (!directoryExists(defaultStaticDir)) {
+          console.log("");
+          console.log("WARNING: Profound UI Installation not found in default location.");
+          console.log("");
+        }
+      }
+      else {
+        defaultStaticDir = config.staticFilesDirectory || "htdocs";
+        console.log("");
+        console.log("You can provide the Profound UI directory as a remote URL (e.g. http://myibmi:8080) or as a local directory name. If the directory does not exist, the installer can create it for you.");
+        console.log("");
+      }
+      staticFilesDirectory = await ask("Specify Profound UI static files directory", defaultStaticDir, validateDirectory);
+      if (!IBMi && !isURL(staticFilesDirectory) && !directoryExists(path.resolve(deployDir, staticFilesDirectory))) {
+        console.log("");
+        console.log("The specified directory for Profound UI was not found.");
+        console.log("");
+        let answer = (await ask("Should the installer create the directory and download a copy of Profound UI static files?", "y", validateYesNo)).toUpperCase();
+        downloadStaticFiles = (answer === "Y");
+      }
+      port = Number(await ask("Specify port number for Profound.js server", config.port || 8081, validatePort));
+      
+
+      if (["win32", "darwin", "linux"].includes(os.platform())) {
+        let answer = (await ask("Install with Git integration?", config.gitSupport === false ? "n" : "y" , validateYesNo)).toUpperCase();
+        gitSupport = (answer === "Y");
+      }
+      if (IBMi) {
+        console.log("");
+        profounduiLibrary = (await ask("Specify Profound UI installation library", config.profounduiLibrary || "PROFOUNDUI", validateName)).toUpperCase();
+        let answer = (await ask("Install Profound.js Connector IBM i ILE components?", "y", validateYesNo)).toUpperCase();
+        if (answer === "Y") {
+          connectorLibrary = (await ask("Enter Profound.js Connector library name:", config.connectorLibrary || "PROFOUNDJS", validateName)).toUpperCase();
+          connectorIASP = (await ask("Enter Profound.js Connector library IASP:", config.connectorIASP || "*SYSBAS", validateIASP)).toUpperCase();
+        }
+        const serverInstances = iutils.getIBMiInstances(deployDir);
+        if (serverInstances.length > 1) {
+          console.log("\nWARNING - Multiple STRTCPSVR/ENDTCPSVR instances found for this server in /profoundjs-base/instances:\n");
+          serverInstances.forEach(serverInstance => {
+            console.log(JSON.stringify(serverInstance));
+          });
+        }
+        answer = (await ask("\nCreate/replace server instance configuration for STRTCPSVR/ENDTCPSVR commands?", "y", validateYesNo)).toUpperCase();
+        if (answer === "Y") {
+          let defaultName = "PROFOUNDJS";
+          const defaultOpts = {
+            ccsid: "37",
+            nodePath: process.argv[0],
+            autostart: "1"
+          };
+          const serverInstance = serverInstances[0];
+          if (serverInstance) {
+            defaultName = serverInstance.name;
+            defaultOpts.autostart = "0";
+            for (const name in defaultOpts) {
+              const opt = serverInstance.options.find(option => option.name === name);
+              if (opt) {
+                defaultOpts[name] = opt.value.trim();
+              }
+            }
+          }
+          svrname = (await ask("Server instance name:", defaultName, validateName)).toUpperCase();
+          ccsid = await ask("Specify CCSID for instance " + svrname, defaultOpts.ccsid, isValidCcsid);
+          nodePath = await ask("Specify Node.js path for instance " + svrname, defaultOpts.nodePath, isValidNodePath);
+          autostart = (await ask("Autostart server instance " + svrname + " when TCP/IP starts?", defaultOpts.autostart === "1" ? "y" : "n", validateYesNo)).toUpperCase();
+          autostart = (autostart === "Y");
+        }
+      }
+      
+      // Create/update configuration file.
+      if (fileExists(configPath)) {
+
+        config.staticFilesDirectory = staticFilesDirectory;
+        config.port = port;
+        if (gitSupport === false) {
+          config.gitSupport = false;
+        }
+        else if (config.hasOwnProperty("gitSupport")) {
+          delete config.gitSupport;
+        }
+        if (IBMi) {
+          config.profounduiLibrary = profounduiLibrary;
+          if (connectorLibrary) {
+            config.connectorLibrary = connectorLibrary;
+          }
+          else {
+            if (config.hasOwnProperty("connectorLibrary")) {
+              delete config.connectorLibrary;
+            }
+            if (config.hasOwnProperty("connectorIASP")) {
+              delete config.connectorIASP;
+            }
+          }
+          if (connectorIASP && connectorIASP !== "*SYSBAS") {
+            config.connectorIASP = connectorIASP;
+          }
+          else if (config.hasOwnProperty("connectorIASP")) {
+            delete config.connectorIASP;
+          }
+        }
+        fs.writeFileSync(configPath, stringifyConfig(config));
+        console.log("");
+        console.log("config.js updated.");
+        console.log("");
+
+      }
+      else {
+
+        let content = fs.readFileSync(path.join(iutils.getSetupDir(), "config.js"), "utf8");
+        eval("config = " + content.substr(content.indexOf("{")));
+        config.staticFilesDirectory = staticFilesDirectory;
+        config.port = port;
+        if (connectorLibrary) {
+          config.connectorLibrary = connectorLibrary;
+          if (connectorIASP !== "*SYSBAS") {
+            config.connectorIASP = connectorIASP;
+          }
+        }
+        if (profounduiLibrary) {
+          config.profounduiLibrary = profounduiLibrary;
+        }
+        if (IBMi) {
+          config.showIBMiParmDefn = true;
+        }
+        if (gitSupport === false) {
+          config.gitSupport = false;
+        }
+        // Check if this is a workspace (if so, default to mysql)
+        if (!IBMi && fileExists(path.join(deployDir, "modules", "app", ".noderun", "settings.json"))) {
+          if (config.databaseConnections) delete config.databaseConnections;  // remove property so that it's appended at the end when we set it
+          config.databaseConnections = [{
+            name: "default",
+            default: true,
+            driver: "mysql",
+            driverOptions: {
+              user: "user-name",
+              password: "your-password",
+              host: "localhost",
+              database: "database-name"
+            }
+          }];
+        }
+        content = "\nmodule.exports = ";
+        content += JSON.stringify(config, null, "  ");
+        content += "\n";
+        fs.writeFileSync(configPath, content);
+        console.log("");
+        console.log("config.js created.");
+        console.log("");
+
+      }
+
+    }
+
+    // Complete installation.
+    process.stdin.destroy();
+    let setupArgs = [];
+    if (IBMi) {
+      if (config.connectorLibrary !== undefined) {
+        setupArgs.push("--ibmi-connector-library");
+      }
+      if (svrname) {
+        setupArgs.push("--ibmi-instance=" + svrname);
+        if (autostart) {
+          setupArgs.push("--ibmi-instance-autostart");
+        }
+        else {
+          setupArgs.push("--no-ibmi-instance-autostart");
+        }
+        if (ccsid) {
+          setupArgs.push("--ibmi-instance-ccsid=" + ccsid);
+        }
+        if (nodePath) {
+          setupArgs.push("--ibmi-instance-node-path=" + nodePath);
+        }
+      }
+    }
+    if (downloadStaticFiles) {
+      setupArgs.push("--static-files");
+    }
+    if (["win32", "darwin", "linux"].includes(os.platform()) && config.gitSupport !== false) {
+      setupArgs.push("--nodegit");
+    }
+    if (setupArgs.length === 0) {
+      setupArgs = "";
+    }
+    else {
+      setupArgs = "-- " + setupArgs.join(" ");
+    }
+    try {
+      child_process.execSync(
+        `npm run setup ${setupArgs}`,
+        {
+          cwd: iutils.getPackageDir(),
+          stdio: ["ignore", "inherit", "inherit"]
+        }
+      );
+    }
+    catch {
+      process.exit(1);
+    }
+
+  }
+  catch (error) {
+    process.stdin.destroy();
+    console.error(error);
+    process.exit(1);
+  }
+})();
+
+async function ask(questionParm, defaultAnswer, validationFunction) {
+
+  let question = questionParm;
+  if (defaultAnswer == null) defaultAnswer = "";
+  if (typeof defaultAnswer !== "string") defaultAnswer = String(defaultAnswer);
+    
+  if (defaultAnswer !== "") {
+    let lastChar = question.substr(question.length - 1, 1);
+    if (lastChar === ":" || lastChar === "?") {    
+      question = question.substr(0, question.length - 1) + " (" + defaultAnswer + ")" + lastChar;
+    }
+    else {
+      question = question + " (" + defaultAnswer + ")" + ":";
+    }
+  }
+  question += " ";
+
+  const readlineInterface = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+  });
+  let answer = await new Promise(resolve => {
+    readlineInterface.question(question, function(answer) {
+      readlineInterface.close();
+      resolve(answer);
+    });
+  });
+
+  if (answer == "") answer = defaultAnswer;
+  answer = answer.trim();
+  if (typeof validationFunction === "function" && validationFunction(answer) === false) {
+    answer = await ask(questionParm, defaultAnswer, validationFunction);
+  }
+  return answer;
+
+}
+
+function fileExists(file) {
+  var exists = false;
+  try {
+    var stat = fs.statSync(file);
+    if (stat && stat.isFile()) exists = true;
+  }
+  catch (err) {
+    exists = false;
+  }
+  return exists;
+}
+
+function directoryExists(dir) {
+  var exists = false;
+  try {
+    var stat = fs.statSync(dir);
+    if (stat && stat.isDirectory()) exists = true;
+  }
+  catch (err) {
+    exists = false;
+  }
+  return exists;
+}
+
+function validateName(name) {
+
+  const error = iutils.validateIBMiName(name);
+  if (error) {
+    console.log(error);
+    return false;
+  }
+  return true;
+
+}
+
+function validateIASP(name) {
+
+  const error = iutils.validateIBMiIASP(name);
+  if (error) {
+    console.log(error);
+    return false;
+  }
+  return true;
+
+}
+
+function isURL(path) {
+  if (typeof path !== "string") return false;
+  path = path.toLowerCase();
+  if (path.substr(0, 7) === "http://") return true;
+  if (path.substr(0, 8) === "https://") return true;
+  return false;
+}
+
+function validateDirectory(directory) {
+  if (IBMi) {
+    var ch = directory.substr(0, 1);
+    if (ch !== "/" && ch !== "\\" && !isURL(directory)) {
+      directory = path.join(iutils.getDeployDir(), path.sep, directory);
+    }
+    if (!directoryExists(directory) && !isURL(directory)) {
+      console.log("WARNING: The specified directory was not found. You can create it later or modify the staticFilesDirectory property in config.js.");
+      console.log("");
+    }
+  }
+  return true;  // accept any entry - if directory doesn't exist, simply warn
+}
+
+function validatePort(port) {
+  if (port === "0") return true;
+  port = Number(port);
+  if (!isNaN(port) && port >= 1 && port <= 65535) return true;
+  console.log("Invalid port number. Valid range is 0-65535.");
+  return false;
+}
+
+function isValidNodePath(nodePath) {
+
+  if (!fileExists(nodePath)) {
+    console.log("Path " + nodePath + " does not exist. A valid path name must be entered.");
+    return false;
+  }
+  return true;
+}
+
+function isValidCcsid(ccsid) {
+
+  const error = iutils.validateIBMiCCSID(parseInt(ccsid, 10));
+  if (error) {
+    console.log(error);
+    return false;
+  }
+  return true;
+
+}
+
+function validateYesNo(answer) {
+  answer = answer.toUpperCase();
+  if (answer === "Y" || answer === "YES" || answer === "N" || answer === "NO") return true;
+  console.log("Invalid answer. Use y or n.");
+  return false;
+}
+
+function stringifyConfig(config) {
+
+  // JavaScript functions (like connectorIPFilter) will be lost when doing JSON.stringify,
+  // so we need to do some magic to preserve them.
+  
+  let funkz = [];
+  let configString = "\nmodule.exports = ";
+
+  configString += JSON.stringify(config, (key, val) => {
+      if (typeof val === 'function') {
+        let n = funkz.length;
+        funkz.push(val.toString());
+        return `___function${n}___`;
+      }
+      return val;
+  }, "  ");
+  
+  configString += "\n";
+
+  for (var i=0; i<funkz.length; i++) {
+    configString = configString.replace(`"___function${i}___"`, funkz[i]);
+  }
+
+  return configString;
+
+}

package/setup/complete_install.js

@@ -0,0 +1,22 @@
+
+const child_process = require("child_process");
+
+let args = process.argv.slice(2);
+if (args.length > 0) {
+  args = "-- " + args.join(" ");
+}
+else {
+  args = "";
+}
+
+try {
+  child_process.execSync(
+    `npm run --prefix=node_modules/profoundjs completeInstall ${args}`,
+    {
+      stdio: "inherit"
+    }
+  );
+}
+catch {
+  process.exit(1);
+}

package/setup/config.js

@@ -1,7 +1,7 @@
 
 module.exports = {
   "port": 8081,
-  "staticFilesDirectory": "puisrc/htdocs",
+  "staticFilesDirectory": "htdocs",
   "pathlist": [
     "pjssamples"
   ],

package/setup/install.js

@@ -0,0 +1,63 @@
+
+"use strict";
+
+/*
+
+  This is NPM lifecycle script: postinstall
+
+  * Installs minimal files into the users's deployment directory:
+    - package.json
+    - start.js
+    - complete_install.js
+
+  * All additional installation is done by script 'npm run setup'.
+
+  * After installation, user runs 'node complete_install.js', which creates configuration and kicks off 'npm run setup'.
+
+  NOTE: Output from this script will be suppressed by NPM 7+, unless process ends with non-zero exit code.
+
+*/
+
+const fs = require("fs");
+const iutils = require("./install_utils.js");
+const path = require("path");
+
+const deployDir = iutils.getDeployDir();
+if (!deployDir) {
+  console.error("Can't find deployment directory.");
+  process.exit(1);
+}
+
+// Install files.
+installFile("package.json");
+installFile("start.js");
+installFile("complete_install.js", true);
+
+console.log("\nTo complete installation, run: node complete_install.js\n");
+
+function fileExists(file) {
+  try {
+    const stats = fs.statSync(file);
+    return stats.isFile();
+  }
+  catch (error) {
+    return false;
+  }
+}
+
+function installFile(file, overwrite) {
+  const dest = path.join(deployDir, file);
+  if (overwrite !== true && fileExists(dest)) {
+    console.log(`${file} exists.`);
+  }
+  else {
+    fs.writeFileSync(
+      dest,
+      fs.readFileSync(path.join(__dirname, file)),
+      {
+        flag: overwrite === true ? "w" : "wx"
+      }
+    );
+    console.log(`${file} created.`);
+  }
+}

package/setup/install_utils.js

@@ -0,0 +1,123 @@
+
+"use strict";
+
+/*
+  Utilities for PJS install/setup process.
+*/
+
+const fs = require("fs");
+const path = require("path");
+
+exports.getConfigPath = function() {
+
+  return path.join(exports.getDeployDir(), "config.js");
+
+}
+
+exports.getDeployDir = function() {
+
+  const dirParts = __dirname.split(path.sep);
+  while (dirParts.length > 0 && dirParts.pop() !== "node_modules") {};
+  if (dirParts.length > 0) {
+    return dirParts.join(path.sep);
+  }
+
+}
+
+exports.getPackageDir = function() {
+
+  return path.resolve(__dirname, "..");
+
+}
+
+exports.getSetupDir = function() {
+
+  return path.join(exports.getPackageDir(), "setup");
+
+}
+
+exports.getIBMiInstances = function(installDir) {
+
+  const INSTANCES_DIR = "/profoundjs-base/instances";
+
+  if (!fs.existsSync(INSTANCES_DIR)) {
+    return [];
+  }
+
+  const dirs = fs.readdirSync(
+    INSTANCES_DIR,
+    {
+      withFileTypes: true
+    }
+  )
+  .filter(el => el.isDirectory());
+
+  let instances = [];
+  for (const dir of dirs) {
+    let conf;
+    try {
+      conf = fs.readFileSync(path.join(INSTANCES_DIR, dir.name, "conf"), "utf8");
+    }
+    catch (error) {
+      continue;
+    }
+    const instance ={
+      name: dir.name.toUpperCase(),
+      options: []
+    };
+    const lines = conf.split("\n");
+    for (const line of lines) {
+      const parts = line.split("=");
+      if (parts.length >= 2) {
+        instance.options.push({
+          name: parts[0].trim(),
+          value: parts.slice(1).join("=")
+        });
+      }
+    }
+    instances.push(instance);
+  }
+  if (installDir) {
+    instances = instances.filter(instance => {
+      const startFile = instance.options.find(option => option.name === "path");
+      return startFile && startFile.value.trim() === path.join(installDir, "start.js");
+    });
+  }
+  return instances;
+
+}
+
+exports.validateIBMiCCSID = function(ccsid) {
+
+  if (!Number.isInteger(ccsid) || ccsid < 1 || ccsid > 65535) {
+    return "CCSID must be a number 1-65535";
+  }
+
+}
+
+exports.validateIBMiIASP = function(name) {
+
+  if (name.toUpperCase() !== "*SYSBAS") {
+    return exports.validateIBMiName(name);
+  }
+
+}
+
+exports.validateIBMiName = function(name) {
+
+  if (name.length < 1 || name.length > 10) {
+    return "Name must be from 1-10 characters.";
+  }
+
+  const firstChar = name.substr(0, 1).toUpperCase();
+  if ((firstChar < "A" || firstChar > "Z") && firstChar != "#" && firstChar != "@" && firstChar != "$") {
+    return "Name must start with either a character A-Z, #, @, or $";
+  }
+  for (let i = 1; i < name.length; i++) {
+    const chr = name.substr(i, 1).toUpperCase();
+    if ((chr < "A" || chr > "Z") && (chr < "0" || chr > "9") && chr != "#" && chr != "@" && chr != "$" && chr != "_" && chr != ".") {
+      return "Name contains an invalid character: " + chr;
+    }        
+  }
+
+}