profoundjs 6.0.0-beta.4 → 6.0.0-beta.6

package/setup/complete_install.js

@@ -0,0 +1,405 @@
+#!/usr/bin/env node
+
+"use strict";
+
+/*
+
+  * This script is intended to be run by the user at an interactive shell after a fresh installation.
+
+  * Prompts for configuration values and other installation options.
+  * Creates config.js
+  * Kicks off 'npm run setup' to complete installation.
+
+*/
+
+const child_process = require("child_process");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const readline = require("readline");
+const iutils = require(path.join(__dirname, "node_modules", "profoundjs", "setup", "install_utils.js"));
+
+const IBMi = os.type() === "OS400";
+
+(async () => {
+  try {
+
+    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) : {};
+
+    // Get configuration values.
+    let staticFilesDirectory, port, downloadStaticFiles, gitSupport;
+    let profounduiLibrary, connectorLibrary, connectorIASP;
+    let svrname, autostart, ccsid, nodePath;
+
+    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();
+    const args = [];
+    if (gitSupport) {
+      args.push("--nodegit");
+    }
+    if (downloadStaticFiles) {
+      args.push("--static-files");
+    }
+    if (connectorLibrary) {
+      args.push("--ibmi-connector-library");
+    }
+    if (svrname) {
+      args.push("--ibmi-instance=" + svrname);
+      args.push("--ibmi-instance-ccsid=" + ccsid);
+      args.push("--ibmi-instance-node-path=" + nodePath);
+      if (autostart) {
+        args.push("--ibmi-instance-autostart");
+      }
+      else {
+        args.push("--no-ibmi-instance-autostart");
+      }
+    }
+    try {
+      child_process.execSync(
+        `node setup.js ${args.join(" ")}`,
+        {
+          cwd: iutils.getSetupDir(),
+          stdio: ["ignore", "inherit", "inherit"]
+        }
+      );
+    }
+    catch (error) {
+      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/config.js

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

package/setup/install.js

@@ -0,0 +1,148 @@
+
+"use strict";
+
+/*
+
+  This is NPM lifecycle script: postinstall
+
+  * Installs additional platform-specific dependencies:
+    - IBMi: idb-connector
+    - Other platforms: profoundjs-node-pty
+
+  * 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'.
+    - If 'config.js' is present in deployment directory, this script kicks off 'npm run setup' automatically.
+     - Otherwise (i.e. fresh installation) user manually runs 'complete_install.js' to configure and complete installation.
+
+  NOTE: Output from this script will be suppressed by NPM 7+, unless process ends with non-zero exit code.
+
+*/
+
+// Platform-specific dependency versions.
+const idb_connector_version = "1.2.16";
+const node_pty_version = "^2";
+
+const child_process = require("child_process");
+const fs = require("fs");
+const iutils = require("./install_utils.js");
+const os = require("os");
+const path = require("path");
+
+const IBMi = os.type() === "OS400";
+
+const deployDir = iutils.getDeployDir();
+if (!deployDir) {
+  console.error("Can't find deployment directory.");
+  process.exit(1);
+}
+
+// Install platform-specific dependencies.
+if (IBMi) {
+  console.log(`Installing idb-connector...`);
+  child_process.execSync(
+    `npm install --no-package-lock idb-connector@"${idb_connector_version}"`,
+    {
+      cwd: iutils.getPackageDir(),
+      stdio: "inherit"
+    }
+  );
+}
+else {
+  console.log(`Installing profoundjs-node-pty...`);
+  child_process.execSync(
+    `npm install --save-optional --no-package-lock profoundjs-node-pty@"${node_pty_version}"`,
+    {
+      cwd: iutils.getPackageDir(),
+      stdio: "inherit"
+    }
+  );
+}
+
+// Install files.
+installFile("package.json");
+installFile("start.js");
+installFile("complete_install.js", true);
+
+// If config.js is present, run 'npm run setup' to complete installation.
+const configPath = iutils.getConfigPath();
+if (fileExists(configPath)) {
+  console.log("\nconfig.js exists. Completing installation.\n");
+  const config = require(configPath);
+  let args = [];
+  if (IBMi) {
+    if (config.connectorLibrary !== undefined) {
+      args.push("--ibmi-connector-library");
+    }
+    const instances = iutils.getIBMiInstances(deployDir);
+    if (instances.length > 0) {
+      const instance = instances[0];
+      args.push("--ibmi-instance=" + instance.name);
+      let opt = getOpt("autostart");
+      if (opt && opt.value === "1") {
+        args.push("--ibmi-instance-autostart");
+      }
+      opt = getOpt("ccsid");
+      if (opt) {
+        args.push("--ibmi-instance-ccsid=" + opt.value);
+      }
+      opt = getOpt("nodePath");
+      if (opt) {
+        args.push("--ibmi-instance-node-path=" + opt.value);
+      }
+      function getOpt(name) {
+        return instance.options.find(opt => opt.name === name);
+      }
+    }
+  }
+  if (["win32", "darwin", "linux"].includes(os.platform()) && config.gitSupport !== false) {
+    args.push("--nodegit");
+  }
+  if (args.length === 0) {
+    args = "";
+  }
+  else {
+    args = "-- " + args.join(" ");
+  }
+  child_process.execSync(
+    `npm run setup ${args}`,
+    {
+      cwd: iutils.getPackageDir(),
+      stdio: ["ignore", "inherit", "inherit"]
+    }
+  );
+}
+else {
+  console.log("\nconfig.js does not exist.");
+  console.log("To configure and 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;
+    }        
+  }
+
+}