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

package/lib/scaffold/action-wrapper.js

@@ -0,0 +1,36 @@
+const ora = require('ora');
+
+/**
+ * Decorate a create action with spinner.
+ * If an action throws, a fail spinner will render for the step, regardless of
+ * if the spinner was started or not.
+ *
+ * @param {String} label - Label for the spinner
+ * @param {Function} fn - Action to wrap
+ * @param {Boolean} startSpinner - Should the spinner start
+ * @returns {Function} decorated action
+ */
+module.exports = function withSpinner(label, fn, { startSpinner = true } = {}) {
+
+  /**
+   * Decorated function
+   *
+   * @param {CreateContext} context - Create context
+   * @returns {Promise} promise
+   */
+  async function wrapper(context) {
+    const spinner = ora(label);
+    if (startSpinner) spinner.start();
+    try {
+      await fn(context, spinner);
+      if (spinner.isSpinning) spinner.succeed();
+    } catch (err) {
+      spinner.fail();
+      context.errors.push(err.stack);
+      throw err;
+    }
+  }
+
+  wrapper.wrapped = fn;
+  return wrapper;
+};

package/lib/scaffold/actions/apply-preset-config.js

@@ -0,0 +1,29 @@
+const { flattenPresets } = require('@gasket/resolve');
+const action = require('../action-wrapper');
+
+/**
+ * Extracts predefined createContext from presets and applies to context.
+ * This allows presets to preemptively define fill in the create context.
+ * This will prevent prompts from appearing for the associated prompts.
+ *
+ * For example, `presetContext` contains `appDescription`, the prompt for the
+ * newly created app's description will not appear.
+ *
+ * We take whatever is in the context at a higher priority, because any
+ * config that is the context at this point must come from CLI flags,
+ * as none of the global prompts have run yet. Parent presets take priority
+ * over extended presets.
+ *
+ * @param {CreateContext} context - Create context
+ */
+function applyPresetConfig(context) {
+  const { presetInfos = [] } = context;
+
+  const presetContext = flattenPresets(presetInfos).reduce((acc, presetInfo) => {
+    return { ...(presetInfo.module && presetInfo.module.createContext || {}), ...acc };
+  }, context);
+
+  Object.assign(context, presetContext);
+}
+
+module.exports = action('Apply preset context', applyPresetConfig, { startSpinner: false });

package/lib/scaffold/actions/cli-version.js

@@ -0,0 +1,84 @@
+const semver = require('semver');
+const { flattenPresets } = require('@gasket/resolve');
+const action = require('../action-wrapper');
+const pkgVersion = require('../../../package.json').version;
+const pkgVersionCompatible = `^${pkgVersion}`;
+
+/**
+ * Helper to check if a module version is a file path
+ *
+ * @param {string} v - Version to check
+ * @returns {Boolean} result
+ */
+const isFile = v => v && v.includes('file:');
+
+/**
+ * Determines the active cli version, and the version required to be installed for app.
+ *
+ * @param {CreateContext} context - Create context
+ * @param {Spinner} spinner - Spinner
+ */
+function resolveCliVersion(context, spinner) {
+  const { presetInfos, warnings } = context;
+
+  //
+  // Gather presets with cli dependencies
+  //
+  const cliPresets = flattenPresets(presetInfos)
+    .map(p => p.package)
+    .filter(p => p.dependencies && p.dependencies['@gasket/cli']);
+
+  //
+  // Find the preset with minimum cli version required.
+  // File paths are always preferred; for integration tests and local development
+  //
+  const minPreset = cliPresets.reduce((acc, cur) => {
+    const nextVersion = cur.dependencies['@gasket/cli'];
+    const prevVersion = acc && acc.dependencies['@gasket/cli'];
+    if (isFile(nextVersion)) return cur;
+    if (isFile(prevVersion)) return acc;
+    return !acc || semver.gt(semver.coerce(prevVersion), semver.coerce(nextVersion)) ? cur : acc;
+  }, null);
+
+  const requiredVersion = minPreset && minPreset.dependencies['@gasket/cli'];
+
+  //
+  // Issue warnings if determined cli version does not meet a preset's requirements
+  //
+  if (requiredVersion && !isFile(requiredVersion)) {
+    let hasWarning = false;
+    cliPresets.forEach(p => {
+      const v = p.dependencies['@gasket/cli'];
+      // installed version mismatch
+      if (!semver.satisfies(semver.coerce(v).version, requiredVersion)) {
+        warnings.push(
+          `Installed @gasket/cli@${requiredVersion} for ${minPreset.name}@${minPreset.version} ` +
+          `which does not satisfy version (${v}) ` +
+          `required by ${p.name}@${p.version}`
+        );
+        hasWarning = true;
+      }
+    });
+
+    //
+    // Issue warnings if globally installed version mismatch with app installed
+    //
+    if (!semver.satisfies(pkgVersion, requiredVersion)) {
+      warnings.push(
+        `Installed @gasket/cli@${requiredVersion} ` +
+        `which is not compatible with global version (${pkgVersion}) ` +
+        `used to execute \`gasket create\``
+      );
+      hasWarning = true;
+    }
+
+    if (hasWarning) spinner.warn('CLI version mismatch');
+  }
+
+  Object.assign(context, {
+    cliVersion: pkgVersion,
+    cliVersionRequired: requiredVersion || pkgVersionCompatible
+  });
+}
+
+module.exports = action('Resolve CLI versions', resolveCliVersion, { startSpinner: false });

package/lib/scaffold/actions/create-hooks.js

@@ -0,0 +1,26 @@
+const createEngine = require('../create-engine');
+const action = require('../action-wrapper');
+const ConfigBuilder = require('../config-builder');
+const Files = require('../files');
+
+/**
+ * Executes the `create` hook for all registered plugins.
+ * Adds `files` to context for plugins to add their files and templates.
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+async function createHooks(context) {
+  const { dest, presets = [], plugins = [], warnings } = context;
+
+  const files = new Files();
+  const gasketConfig = ConfigBuilder.create({}, { orderBy: ['plugins'], warnings });
+  Object.assign(context, { files, gasketConfig });
+
+  const gasket = await createEngine({ dest, presets, plugins });
+  await gasket.execApply('create', async function applyCreate(plugin, handler) {
+    await handler(context.runWith(plugin));
+  });
+}
+
+module.exports = action('Execute create hooks', createHooks);

package/lib/scaffold/actions/generate-files.js

@@ -0,0 +1,183 @@
+/* eslint-disable max-statements */
+const debug = require('diagnostics')('gasket:create-gasket-app:generate-files');
+const fs = require('fs').promises;
+const { promisify } = require('util');
+const Handlebars = require('handlebars');
+const path = require('path');
+const mkdirp = require('mkdirp');
+const { dim } = require('chalk');
+const action = require('../action-wrapper');
+
+const glob = promisify(require('glob'));
+const flatten = (acc, values) => (acc || []).concat(values);
+const reSep = /[/\\]+/;
+const joinSep = pthArr => pthArr.join(path.sep);
+const splitSep = pthStr => pthStr.split(reSep);
+
+/**
+ * Find all duplicate target files and reduce to single descriptor.
+ * Keeps track of overrides.
+ * Last in wins.
+ *
+ * @param {object[]} descriptors - Details about files to generate
+ * @returns {object[]} descriptors
+ */
+function reduceDescriptors(descriptors) {
+  const reduced = descriptors.reduce((acc, desc) => {
+    const { target } = desc;
+    if (acc.has(target)) {
+      const prev = acc.get(target);
+      if (prev.from !== desc.from) {
+        debug(`Using "${target}" from ${desc.from} instead of ${prev.from}`);
+        desc.overrides = prev.from;
+      }
+    }
+    acc.set(target, desc);
+    return acc;
+  }, new Map());
+
+  return Array.from(reduced.values());
+}
+
+/**
+ * Assemble the description objects from glob results
+ *
+ * @param {string} dest - app destination
+ * @param {string} from - Plugin source name
+ * @param {string} pattern - pattern to glob
+ * @param {string[]} srcPaths - resulting paths from glob
+ * @returns {object[]} descriptors
+ */
+function assembleDescriptors(dest, from, pattern, srcPaths) {
+  const output = joinSep(splitSep(dest));
+  const baseParts = splitSep(path.resolve(pattern.replace(/[/\\]+\.?\*.*$/, '')));
+  const base = joinSep(baseParts);
+  return srcPaths.map((srcPath) => {
+    const parts = splitSep(srcPath);
+    const srcFile = joinSep(parts);
+    const target = joinSep(parts.slice(baseParts.length)).replace('.template', '');
+    return {
+      pattern,
+      base,
+      srcFile,
+      targetFile: joinSep([output, target]),
+      target,
+      from
+    };
+  });
+}
+
+/**
+ * Build a list of descriptions of all files we want to generate
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {object[]} descriptors
+ */
+async function getDescriptors(context) {
+  const { dest, files } = context;
+  const descriptors = (
+    await Promise.all(files.globSets.map(async set => {
+      const { globs, source } = set;
+      const matches = await Promise.all(globs.map(async pattern => {
+        pattern = splitSep(pattern).join('/');  // Glob uses / for all OS's
+        const srcPaths = await glob(pattern, { nodir: true });
+        return assembleDescriptors(dest, source.name, pattern, srcPaths);
+      }));
+      return matches.reduce(flatten);
+    }))
+  ).reduce(flatten);
+
+  return reduceDescriptors(descriptors);
+}
+
+/**
+ * Read file content, apply templating, then write out target file.
+ *
+ * @param {CreateContext} context - Create context
+ * @param {object[]} descriptors - Details about files to generate
+ * @returns {boolean} hasWarnings
+ */
+async function performGenerate(context, descriptors) {
+  const { warnings, errors, generatedFiles } = context;
+  let hasWarning = false;
+  let hasError = false;
+
+  const handlebars = Handlebars.create();
+  handlebars.registerHelper('json', JSON.stringify);
+  handlebars.registerHelper('jspretty', (data) => {
+    return JSON.stringify(data).replace(/"/g, '\'');
+  });
+
+  debug('descriptors', JSON.stringify(descriptors, null, 2));
+
+  await Promise.all(descriptors.map(async desc => {
+    const targetDir = path.dirname(desc.targetFile);
+    let content;
+
+    try {
+      const source = await fs.readFile(desc.srcFile, { encoding: 'utf8' });
+      content = source;
+      try {
+        content = handlebars.compile(source)(context);
+      } catch (compileErr) {
+        hasWarning = true;
+        warnings.push(`Error templating ${desc.targetFile}: ${compileErr.message}`);
+      }
+    } catch (readErr) {
+      if (readErr.code === 'EISDIR') {
+        // Skipping directory errors.
+        // node-glob seems to incorrectly captures some directories on Windows
+        hasWarning = true;
+        warnings.push(`Directory matched as template file: ${desc.targetFile}`);
+      } else {
+        hasError = true;
+        errors.push(`Error reading template ${desc.srcFile}: ${readErr.message}`);
+      }
+    }
+    if (!content) return;
+
+    try {
+      await mkdirp(targetDir);
+      try {
+        await fs.writeFile(desc.targetFile, content, { encoding: 'utf8' });
+        const message = desc.target + (desc.overrides ? dim(` – from ${desc.from}`) : '');
+        generatedFiles.add(message);
+      } catch (writeErr) {
+        hasError = true;
+        errors.push(`Error writing ${desc.targetFile}: ${writeErr.message}`);
+      }
+    } catch (err) {
+      hasError = true;
+      errors.push(`Error creating directory ${targetDir}: ${err.message}`);
+    }
+  }));
+
+  return [hasWarning, hasError];
+}
+
+/**
+ * Generate the app files and templates using context
+ *
+ * @param {CreateContext} context - Create context
+ * @param {Spinner} spinner - Spinner
+ * @returns {Promise} promise
+ */
+async function generateFiles(context, spinner) {
+  const { files } = context;
+
+  if (!files.globSets.length) {
+    return;
+  }
+
+  let descriptors = await getDescriptors(context);
+  descriptors = reduceDescriptors(descriptors);
+  const [hasWarnings, hasError] = await performGenerate(context, descriptors);
+
+  if (hasWarnings) spinner.warn();
+  if (hasError) spinner.fail();
+}
+
+module.exports = action('Generate app contents', generateFiles);
+// exported for unit testing
+module.exports._getDescriptors = getDescriptors;
+module.exports._assembleDescriptors = assembleDescriptors;

package/lib/scaffold/actions/global-prompts.js

@@ -0,0 +1,161 @@
+const inquirer = require('inquirer');
+const { pluginIdentifier, flattenPresets } = require('@gasket/resolve');
+const action = require('../action-wrapper');
+const { addPluginsToContext } = require('../utils');
+
+/**
+ * What is your app description?
+ *
+ * @param {CreateContext} context - Create context
+ * @param {function} prompt - function to prompt user
+ * @returns {Promise} promise
+ */
+async function chooseAppDescription(context, prompt) {
+  if (!('appDescription' in context)) {
+    const { appDescription } = await prompt([
+      {
+        name: 'appDescription',
+        message: 'What is your app description?',
+        type: 'input',
+        default: 'A basic gasket app'
+      }
+    ]);
+
+    Object.assign(context, { appDescription });
+  }
+}
+
+/**
+ * What package manager do you want to use?
+ *
+ * @param {CreateContext} context - Create context
+ * @param {function} prompt - function to prompt user
+ * @returns {Promise} promise
+ */
+async function choosePackageManager(context, prompt) {
+  const packageManager =
+    context.packageManager ||
+    (
+      await prompt([
+        {
+          name: 'packageManager',
+          message: 'Which packager would you like to use?',
+          type: 'list',
+          choices: [{ name: 'npm' }, { name: 'yarn' }]
+        }
+      ])
+    ).packageManager;
+
+  const installCmd = context.installCmd || `${packageManager} install`;
+
+  const runners = {
+    npm: 'npx',
+    yarn: 'yarn'
+  };
+
+  const localCmd = context.localCmd || `${runners[packageManager]} gasket local`;
+
+  Object.assign(context, {
+    packageManager,
+    installCmd,
+    localCmd
+  });
+}
+
+/**
+ * Choose your unit test suite
+ *
+ * @param {CreateContext} context - Create context
+ * @param {function} prompt - function to prompt user
+ * @returns {Promise} promise
+ */
+async function chooseTestPlugin(context, prompt) {
+  // Combine user-provided plugins with preset-provided plugins.
+  const { presetInfos = [], plugins = [] } = context;
+
+  // Flatten all plugins from presets and concat short names with cli plugins
+  const allPlugins = flattenPresets(presetInfos)
+    .map((presetInfo) => presetInfo.plugins || [])
+    .reduce((acc, arr) => acc.concat(arr), [])
+    .map((pluginInfo) => pluginIdentifier(pluginInfo.name).shortName)
+    .concat(plugins);
+
+  const knownTestPlugins = { mocha: '@gasket/mocha', jest: '@gasket/jest', cypress: '@gasket/cypress' };
+
+  if (!('testPlugin' in context)) {
+    let testPlugin = Object.values(knownTestPlugins).find((p) => allPlugins.includes(p));
+
+    if ('testSuite' in  context) {
+      testPlugin = knownTestPlugins[context.testSuite];
+    }
+
+    if (!testPlugin) {
+      ({ testPlugin } = await prompt([
+        {
+          name: 'testPlugin',
+          message: 'Choose your unit test suite',
+          type: 'list',
+          choices: [
+            { name: 'none (not recommended)', value: 'none' },
+            { name: 'mocha + nyc + sinon + chai', value: '@gasket/mocha' },
+            { name: 'jest', value: '@gasket/jest' },
+            { name: 'cypress', value: '@gasket/cypress' }
+          ]
+        }
+      ]));
+    }
+
+    if (testPlugin && testPlugin !== 'none') {
+      addPluginsToContext([testPlugin], context);
+      Object.assign(context, { testPlugin });
+    }
+  }
+}
+
+/**
+ * Given that gasket is creating in an already existing directory, it should
+ * confirm with the user that it's intentionally overwriting that directory
+ *
+ * @param  {CreateContext} context - Create context
+ * @param {function} prompt - function to prompt user
+ * @returns {Promise} promise
+ */
+async function allowExtantOverwriting(context, prompt) {
+  const { dest, extant } = context;
+  if (extant && !('destOverride' in context)) {
+    const { destOverride } = await prompt([
+      {
+        name: 'destOverride',
+        type: 'confirm',
+        message: `Override contents of ${dest} ?`,
+        default: true
+      }
+    ]);
+
+    Object.assign(context, { destOverride });
+  }
+}
+
+const questions = [
+  chooseAppDescription,
+  choosePackageManager,
+  chooseTestPlugin,
+  allowExtantOverwriting
+];
+
+/**
+ * Fire off prompts for user input
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+async function globalPrompts(context) {
+  const prompt = context.prompts ? inquirer.prompt : () => ({});
+  for (var fn of questions) {
+    await fn(context, prompt);
+  }
+}
+
+module.exports = action('Global prompts', globalPrompts, { startSpinner: false });
+
+module.exports.questions = questions;

package/lib/scaffold/actions/index.js

@@ -0,0 +1,36 @@
+
+const mkDir = require('./mkdir');
+const loadPreset = require('./load-preset');
+const cliVersion = require('./cli-version');
+const globalPrompts = require('./global-prompts');
+const setupPkg = require('./setup-pkg');
+const writePkg = require('./write-pkg');
+const installModules = require('./install-modules');
+const linkModules = require('./link-modules');
+const writeGasketConfig = require('./write-gasket-config');
+const loadPkgForDebug = require('./load-pkg-for-debug');
+const promptHooks = require('./prompt-hooks');
+const createHooks = require('./create-hooks');
+const generateFiles = require('./generate-files');
+const postCreateHooks = require('./post-create-hooks');
+const applyPresetConfig = require('./apply-preset-config');
+const printReport = require('./print-report');
+
+module.exports = {
+  mkDir,
+  loadPreset,
+  cliVersion,
+  globalPrompts,
+  setupPkg,
+  writePkg,
+  installModules,
+  linkModules,
+  writeGasketConfig,
+  loadPkgForDebug,
+  promptHooks,
+  createHooks,
+  postCreateHooks,
+  generateFiles,
+  applyPresetConfig,
+  printReport
+};

package/lib/scaffold/actions/install-modules.js

@@ -0,0 +1,18 @@
+const action = require('../action-wrapper');
+
+/**
+ * Installs node_modules using the selected package manager
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+async function installModules(context) {
+  const { pkgManager } = context;
+
+  await pkgManager.install();
+}
+
+
+module.exports = action('Install node modules', installModules);
+
+module.exports.update = action('Update node modules', installModules);

package/lib/scaffold/actions/link-modules.js

@@ -0,0 +1,21 @@
+const action = require('../action-wrapper');
+
+/**
+ * Links local packages using the selected package manager
+ *
+ * @param {CreateContext} context - Create context
+ * @param {Spinner} spinner - Spinner
+ * @returns {Promise} promise
+ */
+async function linkModules(context, spinner) {
+  const { pkgLinks, pkgManager } = context;
+
+  if (pkgLinks && pkgLinks.length) {
+    spinner.start();
+    await pkgManager.link(pkgLinks);
+  }
+}
+
+module.exports = action('Link node modules', linkModules, { startSpinner: false });
+
+module.exports.update = action('Relink node modules', linkModules, { startSpinner: false });

package/lib/scaffold/actions/load-pkg-for-debug.js

@@ -0,0 +1,24 @@
+const path = require('path');
+const fs = require('fs').promises;
+const action = require('../action-wrapper');
+const ConfigBuilder = require('../config-builder');
+
+/**
+ * Debug-only load existing app package.json for context.pkg
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+async function loadPkForDebug(context) {
+  const { dest, warnings } = context;
+
+  const filePath = path.join(dest, 'package.json');
+
+  const contents = await fs.readFile(filePath, 'utf8');
+  const fields = JSON.parse(contents);
+  const pkg = ConfigBuilder.createPackageJson(fields, { warnings });
+
+  Object.assign(context, { pkg });
+}
+
+module.exports = action('Load package.json for debug. 🐲 Here be dragons!', loadPkForDebug);