create-gasket-app 7.0.0-cli.7 → 7.0.0-next.1

package/lib/scaffold/fetcher.js

@@ -0,0 +1,194 @@
+const path = require('path');
+const fs = require('fs');
+const { rename, unlink } = fs.promises;
+const tar = require('tar-fs');
+const zlib = require('zlib');
+const pump = require('pump');
+const mkdirp = require('mkdirp');
+const debug = require('diagnostics')('gasket:create-gasket-app:fetcher');
+const { PackageManager } = require('@gasket/utils');
+
+/**
+ * Simple helper class that can also be re-used in tests for similar
+ * file I/O operations
+ */
+const Fetcher = class Fetcher {
+  constructor(opts = {}) {
+    this.dir = path.join(opts.tmp || require('os').tmpdir(), this._id());
+    debug('tmpdir', this.dir);
+  }
+
+  /**
+   * Ensures an eventually consistent rm -rf (aka rimraf) of
+   * the target sourceDir by atomically moving it into this
+   * tmp directory and then spawning a detached child process
+   * to remove it.
+   * @param  {string} sourceDir Directory within this repository.   *
+   * @returns {Promise} result
+   */
+  async vacuum(sourceDir) {
+    const spawn = require('cross-spawn');
+    const basename = path.basename(sourceDir);
+    const rootDir = path.join(__dirname, '..', '..');
+
+    if (!sourceDir.startsWith(rootDir)) {
+      console.error('Refusing to rimraf vacuum unsafe directory: ', sourceDir);
+      return;
+    }
+
+    await mkdirp(this.dir);
+    try {
+      await rename(sourceDir, path.join(this.dir, basename));
+    } catch (err) {
+      if (err.code === 'ENOENT') return;
+      throw err;
+    }
+
+    const rm = spawn(process.execPath, [
+      require.resolve('rimraf/bin.js'),
+      this.dir
+    ], { detached: true });
+
+    rm.on('error', err => {
+      console.error(`Error removing ${this.dir}: ${err.message}`);
+    });
+  }
+
+  /**
+   * Returns a reasonably unique name for a subdirectory in `os.tmpdir()`
+   * @returns {String} Reasonably unique name
+   * @private
+   */
+  _id() {
+    return `gasket-${process.hrtime().join('-')}`;
+  }
+};
+
+
+/**
+ * Package fetcher that represents the core file system logic
+ * for getting npm packages without having to perform a
+ * configuration.
+ *
+ * @type {PackageFetcher}
+ * @public
+ */
+module.exports = class PackageFetcher {
+  constructor(opts = {}) {
+    this.cwd = opts.cwd || process.cwd();
+    this.packageName = opts.packageName;
+    this.tmp = new Fetcher(opts);
+    debug('init', this.packageName, this.tmp.dir);
+  }
+
+  /**
+   * Simple wrapper around clone that also reads the package.json
+   * from disk once it has been downloaded.
+   *
+   * @returns {Promise<Object>} Parsed package.json for the fetched package.
+   */
+  async readPackage() {
+    const dest = await this.clone();
+    return require(path.join(dest, 'package.json'));
+  }
+
+  /**
+   * Critical path file system operations to pull down the npm package
+   * that represents the desired gasket scaffold, `this.packageName`. The logic
+   * revolves around the assumption:
+   *
+   * 1. Move (i.e. rename(2)) is the only truly atomic file system operation.
+   *
+   * Since we use `npm` as the baseline the algorithm becomes:
+   *
+   * 1. Create the target `tmp` directory to untar into
+   * 2. Fetch the tarball using `npm pack` directly as a child process
+   * 3. Unpack the tarball into the target `tmp` directory
+   *   - All `npm` package tarbals have a nested "package" directory in them.
+   * 4. Remove the tarball created by `npm pack`.
+   *
+   * @returns {Promise<string>} Full path of the cloned destination on local disk.
+   * @public
+   */
+  async clone() {
+    await mkdirp(this.tmp.dir);
+
+    const tarballFile = await this.fetch(this.packageName, this.tmp.dir);
+    const tarball = path.join(this.tmp.dir, tarballFile);
+
+    await this.unpack(tarball, this.tmp.dir);
+
+    try {
+      await unlink(tarball);
+    } catch (e) {
+      // eslint ignore no-empty
+    }
+
+    return path.join(this.tmp.dir, 'package');
+  }
+
+  /**
+   * Fetch the tarball for the scaffold
+   *
+   * @param {string} packageName An npm package name (e.g. @gasket/app-template).
+   * @param {string} [dir] Directory the package needs to be downloaded.
+   * @returns {Promise} A promise represents if fetch succeeds or fails
+   * @public
+   */
+  async fetch(packageName = this.packageName, dir = this.cwd) {
+    const argv = [
+      'pack', packageName,
+      '--loglevel', 'error',
+      '--prefer-online'
+    ];
+
+    const { stdout } = await PackageManager.spawnNpm(argv, {
+      cwd: dir
+    }).catch(err => {
+      // TODO: dump npm stdout and stderr to a more useful location.
+      throw new Error(`Failed to fetch ${packageName}: npm exited with non-zero code\n${err.stdout}\n\n${err.stderr}`);
+    });
+
+    // Remark: we should **always** get a tarball, but is it
+    // worthwhile to validate that assumption?
+    return stdout.split('\n').filter(Boolean)[0];
+  }
+
+  /**
+   * Unpack the tarball into given directory.
+   *
+   * Used from https://github.com/ywangii/await-targz under MIT.
+   *
+   * @param {String} tarball Path for tarball to be extracted
+   * @param {String} dir Path for the file to be extracted
+   * @returns {Promise} A promise represents if unpack tarball succeeds or fails
+   * @public
+   */
+  async unpack(tarball, dir) {
+    return {
+      then: async (fulfill, reject) => {
+        const logOpts = { tarball, dir };
+        const readableStream = fs.createReadStream(tarball).once('error', this._logError(`fs.createReadStream`, logOpts));
+        const unzip = zlib.createUnzip().once('error', this._logError(`zlib.createUnzip`, logOpts));
+        const extract = tar.extract(dir).once('error', this._logError(`tar.extract`, logOpts));
+
+        pump(readableStream, unzip, extract, err => {
+          if (err) return reject(err);
+          fulfill();
+        });
+      }
+    };
+  }
+
+  /*
+   * Simple logging helper for streams.
+   */
+  _logError(msg, context) {
+    return err => { console.log(msg, context, err); };
+  }
+};
+
+//
+// Expose Fetcher onto the exports for re-use
+//
+module.exports.Fetcher = Fetcher;

package/lib/scaffold/files.js

@@ -0,0 +1,30 @@
+/**
+ * Utility for plugins to add files and templates for generating
+ *
+ * @type {Files}
+ */
+module.exports = class Files {
+  constructor() {
+    this.globSets = [];
+  }
+
+  /**
+   * Return array of globs
+   *
+   * @deprecated
+   * @returns {string[]} `globby` compatible patterns
+   */
+  get globs() {
+    return this.globSets.reduce((acc, cur) => [...acc, ...cur.globs], []);
+  }
+
+  /**
+   * Adds the specified `globby` compatible patterns, `globs`,
+   * into the set of all sources for this set of files.
+   * @param {string[]} globs - `globby` compatible patterns
+   * @param {Object} source - Plugin to blame if conflicts arise from this operation.
+   */
+  add({ globs, source }) {
+    this.globSets.push({ globs, source });
+  }
+};

package/lib/scaffold/utils.js

@@ -0,0 +1,115 @@
+const path = require('path');
+const untildify = require('untildify');
+const { pluginIdentifier } = require('@gasket/resolve');
+
+/**
+ * Pushes plugins short names for use in gasket.config.js
+ * Pushes the original plugin identifiers under rawPlugins
+ *
+ * @param {PluginDesc[]} plugins - Plugins names
+ * @param {CreateContext} context - Create context
+ */
+function addPluginsToContext(plugins, context) {
+  context.rawPlugins = context.rawPlugins || [];
+  context.plugins = context.plugins || [];
+
+  context.rawPlugins = plugins.reduce((acc, cur) => {
+    const next = pluginIdentifier(cur);
+
+    // get the index of existing plugins by comparing short names
+    const idx = acc.map(p => pluginIdentifier(p).shortName).indexOf(next.shortName);
+
+    if (idx > -1) {
+      // if the existing plugin does not specify a version, use the next one
+      if (!pluginIdentifier(acc[idx]).version) {
+        acc[idx] = cur;
+      }
+    } else {
+      // if we don't already have an entry, push the next one
+      acc.push(cur);
+    }
+
+    return acc;
+  }, context.rawPlugins);
+
+  context.plugins = plugins.reduce((acc, cur) => {
+    const next = pluginIdentifier(cur).shortName;
+    if (!acc.includes(next)) acc.push(next);
+    return acc;
+  }, context.plugins);
+}
+
+/**
+ * Adds plugins and dependencies of the app package
+ *
+ * @param {PluginDesc[]|pluginIdentifier[]} plugins - Plugins names
+ * @param {PackageJson} pkg - Package builder
+ * @param {String} [field] - Dependency type (Default: dependencies)
+ */
+function addPluginsToPkg(plugins, pkg, field = 'dependencies') {
+  const pluginIds = plugins.map(p => pluginIdentifier(p).withVersion());
+  pkg.add(field, pluginIds.reduce((acc, p) => {
+    if (!acc[p.fullName]) {
+      acc[p.fullName] = p.version;
+    }
+    return acc;
+  }, {}));
+}
+
+/**
+ * Look up registry version of provided plugin descriptions w/o versions set.
+ *
+ * @param {PluginDesc[]|pluginIdentifier[]} plugins - Plugins names
+ * @param {PackageManager} pkgManager - Package manager instance
+ * @returns {Promise<pluginIdentifier[]>} plugins
+ */
+async function getPluginsWithVersions(plugins, pkgManager) {
+  return await Promise.all(
+    plugins.map(async name => {
+      const id = pluginIdentifier(name);
+      if (id.version != null) return id;
+      const version = (await pkgManager.info([id.fullName, 'version'])).data;
+      return id.withVersion(`^${version}`);
+    })
+  );
+}
+
+/**
+ * Takes a file path and transforms it to be absolute if not already
+ *
+ * @param {string} filepath - Path to file that may be relative or have tildy
+ * @returns {string} absolute filepath
+ */
+function ensureAbsolute(filepath) {
+  filepath = untildify(filepath);
+  if (path.isAbsolute(filepath)) return filepath;
+  return path.resolve(process.cwd(), filepath);
+}
+
+
+/**
+ * Parses JSON file or string to assign to context
+ *
+ * @param {CreateContext} context - Create context.
+ * @param {Object} configFlags - flags to read config from
+ * @param {string} configFlags.config - JSON string of config values
+ * @param {string} configFlags.configFile - path to JSON file of config values
+ */
+function readConfig(context, { config, configFile }) {
+  if (config) {
+    const parsedConfig = JSON.parse(config);
+    Object.assign(context, parsedConfig);
+  } else if (configFile) {
+    const parsedConfigFile = require(path.resolve(context.cwd, configFile));
+    Object.assign(context, parsedConfigFile);
+  }
+}
+
+
+module.exports = {
+  addPluginsToContext,
+  addPluginsToPkg,
+  getPluginsWithVersions,
+  ensureAbsolute,
+  readConfig
+};

package/lib/utils/create-option.js

@@ -0,0 +1,20 @@
+const { Option } = require('commander');
+
+/**
+ * createOption - Create a commander option
+ * @param {CLICommandOption} definition - The option configuration
+ * @returns {CommnaderOption} option
+ */
+function createOption(definition) {
+  const option = new Option(...definition.options);
+  const { defaultValue, conflicts, parse, hidden, required } = definition;
+
+  if (conflicts.length) option.conflicts(definition.conflicts);
+  if (hidden) option.hideHelp();
+  if (typeof defaultValue !== 'undefined') option.default(defaultValue);
+  if (parse) option.argParser(parse);
+  if (required) option.makeOptionMandatory();
+  return option;
+}
+
+module.exports = createOption;

package/lib/utils/index.js

@@ -0,0 +1,16 @@
+const processCommand = require('./process-command');
+const processArgs = require('./process-args');
+const processOptions = require('./process-options');
+const createOption = require('./create-option');
+const logo = require('./logo');
+const warnIfOutdated = require('./warn-if-outdated');
+
+
+module.exports = {
+  processCommand,
+  processArgs,
+  processOptions,
+  createOption,
+  logo,
+  warnIfOutdated
+};

package/lib/utils/logo.js

@@ -0,0 +1,14 @@
+const logo = `
+          ▄▄▄▄████▀▀█▄
+      ▄███▀▀▀▀▀▀▀█▄▄██
+    ▄██▀   ▄▄▄▄▄   ▀██▌                  ▄▄▄
+  ▄██▀   ███▀▀▀▀█    ██                   ██              ██
+ █▀▀█   ██▌          ▐█▌  ▄▀▀▀█▄  ▄█▀▀▀▄  ██ ▐██▀ ▄█▀▀█▄ ▀██▀▀
+ █▄▄█   ██▌   ▀▀██   ▐█▌  ▄▄▄▄██  ▀▀█▄▄▄  █████   ██▄▄██  ██
+  ▀██▄   ███▄▄▄▄██   ██   ▀▄▄▄▀█▄ ▀▄▄▄█▀ ▄██▄ ██▄ ▀█▄▄▄▄  ▀█▄▄
+    ▀██▄   ▀▀▀  ▀▀ ▄██▌
+      ▀███▄▄▄▄▄▄▄█▀▀██
+          ▀▀▀▀████▄▄█▀
+`;
+
+module.exports = logo;

package/lib/utils/process-args.js

@@ -0,0 +1,39 @@
+/**
+ * isValidArg - Validates the argument configuration
+ * @param {CLICommandArg} arg The argument configuration
+ * @returns {boolean} True if valid, false otherwise
+ */
+function isValidArg(arg) {
+  const keys = Object.keys(arg);
+  if (arg.required && arg.default) return false;
+  return keys.length &&
+    keys.length <= 4 &&
+    arg.name && arg.description;
+}
+
+/**
+ * processArgs - Process the arguments configuration
+ * @param {CLICommandArg[]} args Array of argument configurations
+ * @returns {ProccesedCLICommandArg[]} Array of argument definitions
+ */
+function processArgs(args) {
+  if (!Array.isArray(args) || !args.every(isValidArg)) throw new Error('Invalid argument(s) configuration');
+
+  return args.reduce((acc, arg) => {
+    const def = [];
+    const { name, description, required = false, default: defaultValue } = arg;
+    if (required) {
+      def.push(`<${name}>`, description);
+    } else {
+      def.push(`[${name}]`, description);
+    }
+
+    if (defaultValue) def.push(defaultValue);
+
+    acc.push(def);
+    return acc;
+
+  }, []);
+}
+
+module.exports = processArgs;

package/lib/utils/process-command.js

@@ -0,0 +1,52 @@
+const { Command } = require('commander');
+const program = new Command();
+const processArgs = require('./process-args');
+const processOptions = require('./process-options');
+const createOption = require('./create-option');
+
+/**
+ * isValidCommand - Validates the command configuration
+ * @param {CLICommand} command The command configuration
+ * @returns {boolean} True if valid, false otherwise
+ */
+function isValidCommand(command) {
+  const keys = Object.keys(command);
+  return keys.length &&
+    keys.length <= 7 &&
+    command &&
+    command.id &&
+    command.description &&
+    command.action &&
+    typeof command.action === 'function';
+}
+
+/**
+ * processCommand - Process the command configuration
+ * @param {CLICommand} command The command configuration
+ * @returns {ProccesedCLICommand} The command instance
+ */
+function processCommand(command) {
+  if (!isValidCommand(command)) throw new Error('Invalid command configuration');
+  const { id, description, action, args, options, hidden = false, default: isDefault = false } = command;
+  const cmd = program
+    .command(id)
+    .description(description)
+    .action(action);
+
+  if (args) {
+    const cmdArgs = processArgs(args);
+    cmdArgs.forEach(arg => cmd.argument(...arg));
+  }
+
+  if (options) {
+    const cmdOpts = processOptions(options);
+    cmdOpts.forEach(o => {
+      const option = createOption(o);
+      cmd.addOption(option);
+    });
+  }
+
+  return { command: cmd, hidden, isDefault };
+}
+
+module.exports = processCommand;

package/lib/utils/process-options.js

@@ -0,0 +1,46 @@
+/**
+ * isValidOption - Validate the option
+ * @param {CLICommandOption} option The option configuration
+ * @returns {boolean} True if valid, false otherwise
+ */
+function isValidOption(option) {
+  const keys = Object.keys(option);
+  return keys.length &&
+    keys.length <= 5 &&
+    option.name &&
+    option.description;
+}
+
+/**
+ * processOptions - Process the options configuration
+ * @param {CLICommandOption[]} options Array of option configurations
+ * @returns {ProccesedCLICommandOption[]} Processed option definitions
+ */
+function processOptions(options) {
+  if (!Array.isArray(options) || !options.every(isValidOption)) throw new Error('Invalid option(s) configuration');
+
+  return options.reduce((acc, option) => {
+    const def = [];
+    const {
+      name,
+      description,
+      required = false,
+      short,
+      parse,
+      type = 'string',
+      conflicts = [],
+      hidden = false,
+      default: defaultValue
+    } = option;
+
+    const format = required ? `<${name}>` : `[${name}]`;
+    const flags = short ? `-${short}, --${name}` : `--${name}`;
+
+    def.push(`${flags}${type !== 'boolean' ? ` ${format}` : ''}`, description);
+    acc.push({ options: def, conflicts, hidden, defaultValue, parse, required });
+
+    return acc;
+  }, []);
+}
+
+module.exports = processOptions;

package/lib/utils/setup.js

@@ -0,0 +1,25 @@
+/**
+ * Step which runs before oclif any everything else is required.
+ * Handles the `--require` flags to allow for early importing of instrumentation
+ * modules and the like.
+ *
+ * @param {string[]} [argv] - CLI arguments - defaults to process.argv
+ */
+module.exports = function setup(argv = process.argv) {
+  // Using to parse args before mounting all of oclif
+  const getopts = require('getopts');
+  const opts = getopts(argv, {
+    alias: {
+      require: ['r']
+    }
+  });
+
+  if (opts.require) {
+    const required = Array.isArray(opts.require) ? opts.require : [opts.require];
+    required.forEach(module => {
+      require(
+        require.resolve(module, { paths: [process.cwd()] })
+      );
+    });
+  }
+};

package/lib/utils/warn-if-outdated.js

@@ -0,0 +1,76 @@
+const { runShellCommand } = require('@gasket/utils');
+const semver = require('semver');
+const chalk = require('chalk');
+const { readFile, writeFile } = require('fs/promises');
+const path = require('path');
+
+const cachePath = path.join(__dirname, '..', '..', '.cache'); // Place at root of gasket-cli
+const LATEST_VERSION = 'latestVersion';
+const LATEST_VERSION_UPDATE_TIME = 'latestVersionUpdateTime';
+
+/**
+ * Checks if the latest version update time is older than seven days
+ * @param {number} currentTime - current time in milliseconds
+ * @param {number} latestVersionUpdateTime - latest version update time in milliseconds
+ * @returns {boolean} - true if latestVersionUpdateTime is older than seven days
+ */
+function isOlderThanSevenDays(currentTime, latestVersionUpdateTime) {
+  const sevenDaysInMillis = 7 * 24 * 60 * 60 * 1000; // Seven days in milliseconds
+  const timeDifference = Math.abs(currentTime - latestVersionUpdateTime);
+  return timeDifference > sevenDaysInMillis;
+}
+
+/**
+ * Fetches the latest version of a package from npm
+ * @param {string} pkgName - package name
+ * @param {number} currentTime - current time in milliseconds
+ * @param {object} cache - cache object
+ * @returns {string} - latest version of the package
+ */
+async function getLatestVersion(pkgName, currentTime, cache) {
+  if (
+    !cache[LATEST_VERSION_UPDATE_TIME] ||
+    !cache[LATEST_VERSION] ||
+    isOlderThanSevenDays(currentTime, cache[LATEST_VERSION_UPDATE_TIME])
+  ) {
+    try {
+      const cmdResult = await runShellCommand('npm', ['view', pkgName, 'version'], {});
+      if (cmdResult?.stdout) {
+        const latestVersion = cmdResult.stdout.trim();
+        cache[LATEST_VERSION_UPDATE_TIME] = currentTime;
+        cache[LATEST_VERSION] = latestVersion;
+        await writeFile(cachePath, JSON.stringify(cache));
+        return latestVersion;
+      }
+    } catch (error) {
+      console.error('Error fetching latest version:', error);
+    }
+  } else {
+    return cache[LATEST_VERSION];
+  }
+}
+
+/**
+ * Warns if the package is outdated
+ * @param {string} pkgName - package name
+ * @param {string} currentVersion - current version of the package
+ */
+module.exports = async function warnIfOutdated(pkgName, currentVersion) {
+  const currentTime = new Date().getTime();
+  let cache = {};
+
+  try {
+    const file = await readFile(cachePath, 'utf8');
+    cache = JSON.parse(file);
+  } catch (error) {
+    // console.error('Error reading cache file:', error);
+  }
+
+  const latestVersion = await getLatestVersion(pkgName, currentTime, cache);
+
+  if (typeof latestVersion === 'string' && semver.gt(latestVersion, currentVersion)) {
+    console.warn(
+      ` ${chalk.yellow('›')}   Warning: ${pkgName} update available from ${chalk.green(latestVersion)} to ${chalk.green(currentVersion)}`
+    );
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-gasket-app",
-  "version": "7.0.0-cli.7",
+  "version": "7.0.0-next.1",
   "description": "starter pack for creating a gasket app",
   "main": "lib",
   "bin": {
@@ -31,10 +31,30 @@
   },
   "homepage": "https://github.com/godaddy/gasket/tree/main/packages/create-gasket-app",
   "dependencies": {
-    "@gasket/cli": "^7.0.0-cli.7"
+    "@gasket/engine": "^7.0.0-next.1",
+    "@gasket/plugin-git": "^7.0.0-next.1",
+    "@gasket/plugin-lifecycle": "^7.0.0-next.1",
+    "@gasket/plugin-logger": "^7.0.0-next.1",
+    "@gasket/plugin-metadata": "^7.0.0-next.1",
+    "@gasket/plugin-start": "^7.0.0-next.1",
+    "@gasket/resolve": "^7.0.0-next.1",
+    "@gasket/utils": "^7.0.0-next.1",
+    "commander": "^12.0.0",
+    "deepmerge": "^4.3.1",
+    "handlebars": "^4.7.8",
+    "inquirer": "6.5.2",
+    "json5": "^2.2.3",
+    "mkdirp": "^1.0.4",
+    "ora": "3.4.0",
+    "pump": "^3.0.0",
+    "semver": "^7.5.4",
+    "tar-fs": "^2.0.0",
+    "untildify": "^4.0.0"
   },
   "devDependencies": {
     "cross-env": "^7.0.3",
+    "diagnostics": "^2.0.2",
+    "dotenv": "^16.4.5",
     "eslint": "^8.56.0",
     "eslint-config-godaddy": "^7.0.2",
     "eslint-plugin-jest": "^27.6.3",
@@ -57,5 +77,5 @@
   "eslintIgnore": [
     "test/fixtures"
   ],
-  "gitHead": "465ca0b08a4a7513935fa60b186a4d1238b12fa6"
+  "gitHead": "05300b094247de1fdfaf06afcdfed24280e3f084"
 }