@leverege/build-tools 2.4.9 → 2.5.0-beta.40

package/lib/server/repo-init/templates/Templates.js

@@ -0,0 +1,279 @@
+"use strict";
+
+/**
+ * Contains the available templates and potential files common to all
+ * templates, along with a JSON config controlling certain aspects of
+ * the available templates.
+ */
+const chalk = require('chalk');
+
+const fs = require('fs');
+
+const inquirer = require('inquirer');
+
+const ncp = require('ncp').ncp;
+
+const path = require('path');
+
+const ToBuildSpec = require('./ToBuildSpec');
+
+class Templates {
+  constructor(config) {
+    Object.assign(this, config);
+  }
+
+  getAll() {
+    return this.config.templates.filter(entry => entry.enabled);
+  }
+
+  lookupTemplateByType(type) {
+    return this.config.templates.find(entry => entry.type === type);
+  }
+
+  lookupTypeByName(name) {
+    const template = this.config.templates.find(entry => entry.name === name);
+    return template.type || 'unknown';
+  }
+
+  lookupSubTypesByType(type) {
+    const template = this.lookupTemplateByType(type);
+    return template.subTypes || [];
+  }
+
+  lookupLogConfig(type) {
+    const logConfigs = {
+      /* eslint-disable key-spacing */
+      'Pino Streaming': '{"type":"pino","level":"debug"}',
+      'Bunyan Streaming': '{"type":"bunyan",level": "debug"',
+      'Bunyan Rotating Files': '{"type":"bunyan-rotating","level":"debug"}'
+      /* eslint-enable key-spacing */
+
+    };
+    return !type ? Object.keys(logConfigs) : logConfigs[type];
+  }
+
+  needsAnIngestionPort(template) {
+    return template.type === 'ingestor' && template.subType !== 'PubSub';
+  }
+
+  async runInquiry(spec) {
+    const templateQs = [{
+      type: 'input',
+      name: 'template.serviceName',
+      message: 'The library or service name to use for logging and such?',
+      default: spec.git.name
+    }, {
+      type: 'list',
+      name: 'template.type',
+      message: 'What type of repository do you wish to create?',
+      choices: this.getAll(),
+      filter: name => {
+        return this.lookupTypeByName(name);
+      }
+    }, {
+      type: 'list',
+      name: 'template.subType',
+      message: 'Select the type of ingestor to create:',
+      choices: this.lookupSubTypesByType('ingestor'),
+      default: 'PubSub',
+      when: answers => {
+        return answers.template.type === 'ingestor';
+      }
+    }, {
+      type: 'number',
+      name: 'template.ingestionPort',
+      message: 'Enter the Ingestion port to use',
+      default: 9999,
+      when: answers => {
+        return this.needsAnIngestionPort(answers.template);
+      }
+    }, {
+      type: 'number',
+      name: 'template.expressPort',
+      message: 'Enter the HTTP/Express port to use',
+      default: 8080,
+      when: answers => {
+        return answers.template.type.match(/express|ingestor/);
+      }
+    },
+    /**
+    {
+      type : 'number',
+      name : 'template.port',
+      message : 'Enter the network port to use',
+      default : 8080,
+      when : ( answers ) => {
+        condir( 'Current Answers=>', answers )//XXX
+        const template = this.lookupTemplateByType( answers.template.type )
+        return (
+          typeof template.port !== 'undefined' &&
+          answers.template.subType !== 'PubSub'
+        )
+      },
+    },
+    */
+    {
+      type: 'confirm',
+      name: 'template.helmify',
+      message: 'Run helmify to generate Helm Charts?',
+      default: false,
+      when: answers => {
+        const template = this.lookupTemplateByType(answers.template.type);
+        return typeof template.helm !== 'undefined';
+      }
+    }, {
+      type: 'list',
+      name: 'dotenv.logConfig',
+      message: 'Your preferred logging method (.env)?',
+      choices: this.lookupLogConfig(),
+      filter: logType => {
+        return this.lookupLogConfig(logType);
+      },
+      when: answers => {
+        return answers.template.type.match(/express|ingestor/);
+      }
+    }, {
+      type: 'input',
+      name: 'dotenv.cmWebServerPort',
+      message: 'The cluster manager web port to use (.env)?',
+      default: 5121,
+      when: answers => {
+        return answers.template.type.match(/express|ingestor/);
+      }
+    }, {
+      type: 'input',
+      name: 'dotenv.imagineURL',
+      message: 'The URL to use to get to the api (.env)?',
+      default: 'http://localhost:8181',
+      when: answers => {
+        return answers.template.type.match(/express|ingestor/);
+      }
+    }];
+    console.log(chalk.green(`
+  The answers to the following questions will describe the type of software
+  repository to generate, as well as define certain configuration parameters
+  expected by the resultant code.
+`));
+    const answers = await inquirer.prompt(templateQs);
+    /**
+     * Augment the answers with the proper config to make it easier to use
+     * that info downstream.
+     */
+
+    return { ...answers,
+      config: this.lookupTemplateByType(answers.template.type)
+    };
+  }
+
+  async build(buildSpec) {
+    /**
+     * Start assembling the desired template by attempting to create
+     * the top level directory.
+     */
+    try {
+      fs.mkdirSync(buildSpec.git.name);
+    } catch (err) {
+      console.log(chalk.yellow.bold(`
+  ${chalk.red.bold(err)}
+           ^^Fix this and try again.
+`));
+      process.exit(1);
+    }
+    /**
+     * The ncp recursive file copying library supports the notion of
+     * filters, and stream transforming. The filter is created to
+     * disallow the copying of any special files that begin with an
+     * underscore character. The transform function connects the spec
+     * building logic to transform special strings into the values in the
+     * active build specification.
+     */
+
+
+    const NcpOptions = {
+      clobber: true,
+      filter: fullName => {
+        const fileRegExp = new RegExp('^[^_]');
+        return fileRegExp.test(path.basename(fullName));
+      },
+      transform: (readStream, writeStream, file) => {
+        const transformer = new ToBuildSpec(buildSpec);
+        readStream.pipe(transformer).pipe(writeStream);
+      }
+    }; // a simple helper to convey _UNDER_CONSTRUCTION_ notes / suggestions
+
+    const warnIfUnderConstruction = (dir, constructionArea) => {
+      const constructionFile = `${dir}/_UNDER_CONSTRUCTION_`;
+
+      if (fs.existsSync(constructionFile)) {
+        const message = fs.readFileSync(constructionFile);
+        console.log(`
+${chalk.yellow.bold(`***WARNING: ${constructionArea} template is marked as Under Construction`)}
+${chalk.blue.bold(message)}
+`);
+      }
+    };
+
+    const checkForPackageAdds = async (source, destination) => {
+      const packageAddsFile = `${source}/_PACKAGE_ADDS_`;
+
+      if (fs.existsSync(packageAddsFile)) {
+        const npmCommands = fs.readFileSync(packageAddsFile).toString('utf-8').split('\n');
+        console.log(`${chalk.yellow.bold('***WARNING: Running Package Adds')}`);
+        const regexp = new RegExp('^([+-]) (\\@*\\w+/*\\w*\\-*\\w*)');
+
+        for (let i = 0; i < npmCommands.length; i++) {
+          const match = npmCommands[i].match(regexp);
+
+          if (!match) {
+            continue;
+          }
+
+          const npmAction = `${match[1] === '+' ? 'install' : 'uninstall'} ${match[2]}`;
+          buildSpec.npmActions.push(`${npmAction} --save`);
+        }
+      }
+    };
+
+    const ncpSync = async (source, destination, options) => {
+      return new Promise((resolve, reject) => {
+        ncp(source, destination, options, err => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve({
+              status: `ncpSync: completed ${source} => ${destination}`
+            });
+          }
+        });
+      });
+    }; // start copying the template files in to the tree.
+
+
+    const destination = buildSpec.git.name;
+    const template = this.config.templates.find(tmpl => tmpl.type === buildSpec.template.type); // copy the typical files to the target tree
+
+    for (let i = 0; i < template.sources.length; i++) {
+      const source = template.sources[i];
+      const sourceDir = `${this.configDir}/${source}`;
+      warnIfUnderConstruction(sourceDir, buildSpec.template.type);
+      await ncpSync(sourceDir, destination, NcpOptions); // eslint-disable-line
+
+      checkForPackageAdds(sourceDir, destination); // check for _subTypes
+
+      const subTypeRoot = `${sourceDir}/_subTypes/${buildSpec.template.subType}`;
+      warnIfUnderConstruction(subTypeRoot, `${buildSpec.template.type}/${buildSpec.template.subType}`);
+      const subTypeDest = `${buildSpec.git.name}/src`;
+
+      if (fs.existsSync(subTypeRoot)) {
+        await ncpSync(subTypeRoot, subTypeDest, NcpOptions); // eslint-disable-line
+      }
+
+      checkForPackageAdds(subTypeRoot, destination);
+    }
+  }
+
+}
+
+module.exports = {
+  Templates
+};

package/lib/server/repo-init/templates/ToBuildSpec.js

@@ -0,0 +1,95 @@
+"use strict";
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const {
+  Transform
+} = require('stream');
+/**
+ * This is the stream transform logic that replaces the repo-init special
+ * string of REPI:<BuildSpecVariable> with the contents of the referenced
+ * variable from the buildSpec.
+ */
+
+
+class ToBuildSpec extends Transform {
+  constructor(buildSpec) {
+    super({
+      objectMode: true
+    });
+
+    _defineProperty(this, "_transform", function _transformFunc(chunk, encoding, done) {
+      const chunkStr = chunk.toString();
+      /**
+       * Concern of possible partial strings when working with large files.
+       * In this case, most source will be less than 10K so this should not
+       * be a problem for the most part, but error out if it occurs.
+       */
+
+      if (!chunkStr.endsWith('\n')) {
+        // TODO: This logic if flawed looking for \n
+        console.error(`***PARTIAL LINE***[${chunkStr}]`);
+        process.exit(1); // TODO: throw something not exit
+      }
+      /**
+       * Used for pulling nested or flat values from the buildSpec. This allows
+       * the build spec to look like this:
+       * {
+       *   gitName : 'myName',
+       *   git : {
+       *     name : 'myName',
+       *   }
+       * }
+       * and either can be retrieved with a key of gitName or git.name.
+       */
+
+
+      const valueFromSpec = (key, spec = this.buildSpec) => {
+        if (!key.match(/\.+/)) {
+          return spec[key];
+        }
+
+        const keys = key.split('.');
+        return valueFromSpec(keys[1], spec[keys[0]]);
+      };
+
+      const splitLines = chunkStr.split('\n');
+      const xfmLines = splitLines.map(line => {
+        let replaced = line;
+
+        for (const match of line.matchAll(this.regexp)) {
+          // eslint-disable-line no-restricted-syntax
+          const replaceWith = valueFromSpec(match[1]);
+
+          if (typeof replaceWith === 'undefined') {
+            // console.log( `Skipping unknown build spec property =>[${match[1]}]` )//XXX
+            continue;
+          }
+
+          replaced = replaced.replace(match[0], replaceWith);
+        }
+
+        return replaced;
+      });
+      const xfmString = xfmLines.join('\n');
+      this.push(Buffer.from(xfmString));
+      done();
+    });
+
+    _defineProperty(this, "_flush", function _flushFunc(done) {
+      /**
+        if ( this._partialLine ) {
+          this.push( [ this._partialLine ] )
+        }
+         this._partialLine = null
+        */
+      done();
+    });
+
+    this.buildSpec = buildSpec;
+    this.regexp = new RegExp('REPI:<(\\w+\\.*\\w*)>', 'g');
+  }
+
+}
+
+module.exports = ToBuildSpec;

package/lib/server/repo-init/templates/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const {
+  Templates
+} = require('./Templates');
+
+module.exports = {
+  Templates
+};

package/lib/server/repo-init/utils/Shell.js

@@ -0,0 +1,102 @@
+"use strict";
+
+/**
+ * Shell like things can go in here. I mostly created this to make it
+ * easier to push and pop around the directory trees for repo-init. It
+ * might make sense to add other things in here to make writing node CLI
+ * commands a little less painful.
+ */
+const fs = require('fs');
+
+const process = require('process');
+
+const dirStack = [];
+/**
+ * Simple wrapper functions for debugging.
+ */
+
+const cwd = () => {
+  return process.cwd();
+};
+
+const chdir = dir => {
+  return process.chdir(dir);
+};
+
+const dirs = () => {
+  console.log(dirStack);
+};
+
+const pushd = dir => {
+  if (!dir) {
+    throw new Error('pushd: no other directory');
+  }
+
+  dirStack.push(cwd());
+  chdir(dir);
+};
+
+const throwIfEmptyStack = () => {
+  if (dirStack.length === 0) {
+    throw new Error('popd: directory stack empty');
+  }
+};
+
+const popd = all => {
+  throwIfEmptyStack();
+  chdir(dirStack.pop());
+};
+
+const popdAll = () => {
+  throwIfEmptyStack();
+  chdir(dirStack[0]);
+  dirStack.length = 0;
+};
+/**
+ * This function will do an upwards traversal of a file tree looking for the
+ * specified file. An error will be thrown if the file is not found within
+ * maxLevels.
+ */
+
+
+const reverseFindFile = (findFile, options) => {
+  pushd(options.startDir || cwd());
+  let maxLevels = options.maxLevels || 5;
+  let fileRoot;
+
+  while (maxLevels > 0) {
+    if (fs.existsSync(findFile)) {
+      fileRoot = cwd();
+      break;
+    }
+
+    pushd('..'); // walk up the tree
+
+    maxLevels -= 1;
+  }
+
+  popdAll();
+
+  if (!fileRoot) {
+    throw new Error(`reverseFindFile: ${findFile} not found`);
+  }
+
+  return fileRoot;
+};
+
+const findRepoRoot = () => {
+  return reverseFindFile('package.json', {
+    startDir: __dirname
+  });
+};
+
+module.exports = {
+  dirs,
+  pushd,
+  popd,
+  popdAll,
+  reverseFindFile,
+  findRepoRoot,
+  cwd,
+  chdir
+};

package/lib/server/repo-init/utils/VersionCheck.js

@@ -0,0 +1,82 @@
+"use strict";
+
+const chalk = require('chalk');
+
+const coerce = require('semver/functions/coerce');
+
+const semverLt = require('semver/functions/lt');
+
+const satisfies = require('semver/functions/satisfies');
+/**
+ * This function verifies the specified version falls in this range:
+ *
+ *    minimum >= current < maximum
+ *
+ * The params will be semver coerced where a version of 12 will be coerced
+ * to 12.0.0, a version of 12.18.4-beta.3 will be coerced to 12.18.4.
+ *
+ * Note that this function still has its references to node, but could be
+ * made entirely generic if need be.
+ *
+ * @param {Object} params
+ * @param {String} params.current - version to check
+ * @param {String} params.minimum - can be equal or greater to this
+ * @param {String} params.maximum - must be less than this
+ * @param {String} params.preferred - the most acceptable version
+ */
+
+
+function validate(params = {}) {
+  const throwChalk = error => {
+    const errorStr = chalk.red.bold('***ERROR =>');
+    throw new Error(chalk.keyword('orange').bold(`\n${errorStr} ${error}`));
+  };
+
+  if (!params || !params.current || !params.minimum || !params.maximum) {
+    throwChalk('current, minimum and maximum parameters are required by validate');
+  }
+
+  const coercedVersions = sems => {
+    return Object.keys(sems).reduce((obj, key) => {
+      const coerced = obj; // avoid eslint warning
+
+      coerced[key] = coerce(sems[key]).version;
+      return coerced;
+    }, {});
+  };
+
+  const {
+    current,
+    minimum,
+    maximum,
+    preferred
+  } = coercedVersions(params);
+  /**
+   * Verify that the current version falls within the accepted ranges.
+   */
+
+  const rangeStr = `>=${minimum} <${maximum}`;
+
+  if (!satisfies(current, rangeStr)) {
+    throwChalk(`Version ${current} is outside the accepted range of ${rangeStr}`);
+  }
+  /**
+   * Suggest upgrading to the currently recommended version.
+   */
+
+
+  if (preferred && semverLt(current, preferred)) {
+    console.log(chalk.keyword('orange').bold(`
+  ${chalk.yellow.bold('        *** HEADS UP ***')}
+  Running node version => ${chalk.yellow.bold(`v${current}`)} (which should work)
+  Preferred version is => ${chalk.green.bold(`v${preferred}`)}
+
+  Also, a reinstall of the build-tools may be necessary after any node upgrade
+          ${chalk.cyan.bold('npm i -g @leverege/build-tools')}
+`));
+  }
+}
+
+module.exports = {
+  validate
+};

package/lib/server/repo-init/utils/index.js

@@ -0,0 +1,67 @@
+"use strict";
+
+const inquirer = require('inquirer');
+
+const Shell = require('./Shell');
+
+const VersionCheck = require('./VersionCheck');
+/**
+ * Clears the screen and optionally homes the cursor.
+ */
+
+
+const clear = (home = true) => {
+  // console.log( ( home ? '\x1B[0f' : '' ) + '\x1B[2J' )
+  console.log(`${home ? '\x1B[0f' : ''}\x1B[2J`);
+};
+/**
+ * A simple object dumping convenience.
+ */
+
+
+const condir = (log, thing) => {
+  console.dir({
+    log,
+    thing
+  }, {
+    depth: 8,
+    colors: true
+  }); // eslint-disable-line
+};
+/**
+ * General "yes" to proceed function.
+ */
+
+
+const proceed = async (query = 'Do you wish to proceed?') => {
+  await inquirer.prompt([{
+    type: 'confirm',
+    name: 'proceed',
+    message: query,
+    default: true
+  }]).then(answer => {
+    if (!answer.proceed) {
+      process.exit(0);
+    }
+  });
+};
+/**
+ * A simple mS sleeper.
+ */
+
+
+const sleep = (ms = 0) => {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+};
+
+module.exports = {
+  clear,
+  condir,
+  proceed,
+  sleep,
+  pause: sleep,
+  Shell,
+  VersionCheck
+};