create-gasket-app 7.0.3-cli.0 → 7.2.0-canary.0

package/lib/scaffold/action-wrapper.js

@@ -0,0 +1,37 @@
+import ora from '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
+ */
+export default function withSpinner(label, fn, { startSpinner = true } = {}) {
+  /**
+   * Decorated function
+   *
+   * @param {ActionWrapperParams} params - ActionWrapperParams
+   * @param {GasketEngine} params.gasket - Gasket config
+   * @param {CreateContext} params.context - Create context
+   * @returns {Promise} promise
+   */
+  async function wrapper({ gasket = {}, context }) {
+    const spinner = ora(label);
+    if (startSpinner) spinner.start();
+    try {
+      await fn({ gasket, 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/create-hooks.js

@@ -0,0 +1,25 @@
+import action from '../action-wrapper.js';
+import { ConfigBuilder } from '../config-builder.js';
+import { Files } from '../files.js';
+
+/**
+ * Executes the `create` hook for all registered plugins.
+ * Adds `files` to context for plugins to add their files and templates.
+ *
+ * @param {GasketEngine} gasket - Gasket API
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+async function createHooks({ gasket, context }) {
+  const { plugins = [], warnings } = context;
+
+  const files = new Files();
+  const gasketConfig = ConfigBuilder.create({}, { orderBy: ['plugins'], warnings, plugins });
+  Object.assign(context, { files, gasketConfig });
+
+  await gasket.execApply('create', async function applyCreate(plugin, handler) {
+    await handler(context.runWith(plugin));
+  });
+}
+
+export default action('Execute create hooks', createHooks);

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

@@ -0,0 +1,185 @@
+import { default as diagnostics } from 'diagnostics';
+const debug = diagnostics('gasket:cli:generate-files');
+import fs from 'fs/promises';
+import { promisify } from 'util';
+import Handlebars from 'handlebars';
+import path from 'path';
+import mkdirp from 'mkdirp';
+import chalk from 'chalk';
+const { dim } = chalk;
+import action from '../action-wrapper.js';
+import * as syncGlob from 'glob';
+const glob = promisify(syncGlob.default);
+
+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();
+}
+
+export default action('Generate app contents', generateFiles);
+// exported for unit testing
+export const _getDescriptors = getDescriptors;
+export const _assembleDescriptors = assembleDescriptors;

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

@@ -0,0 +1,158 @@
+import inquirer from 'inquirer';
+import action from '../action-wrapper.js';
+
+/**
+ * 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 and integration test suite
+ *
+ * @param {CreateContext} context - Create context
+ * @param {function} prompt - function to prompt user
+ * @returns {Promise} promise
+ */
+async function chooseTestPlugins(context, prompt) {
+  const knownTestPlugins = {
+    unit: { mocha: '@gasket/plugin-mocha', jest: '@gasket/plugin-jest' },
+    integration: { cypress: '@gasket/plugin-cypress' }
+  };
+
+  const testTypes = ['unit', 'integration'];
+  const testPlugins = [];
+
+  if (!('testPlugins' in context)) {
+    for (const type of testTypes) {
+      if (type + 'TestSuite' in context) {
+        const testSuite = knownTestPlugins[type][context[type + 'TestSuite']];
+        if (testSuite) testPlugins.push(testSuite);
+      } else {
+        const plugin = await promptForTestPlugin(
+          prompt,
+          `Choose your ${type} test suite`,
+          Object.entries(knownTestPlugins[type]).map(([name, value]) => ({ name, value }))
+        );
+
+        if (plugin) testPlugins.push(plugin);
+      }
+    }
+
+    if (testPlugins.length > 0) {
+      Object.assign(context, { testPlugins });
+    }
+  }
+}
+
+async function promptForTestPlugin(prompt, message, choices) {
+  const { testPlugin } = await prompt([
+    {
+      name: 'testPlugin',
+      message,
+      type: 'list',
+      choices: [{ name: 'none', value: 'none' }, ...choices]
+    }
+  ]);
+
+  return testPlugin !== 'none' ? testPlugin : null;
+}
+
+/**
+ * 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 });
+  }
+}
+
+export const questions = [
+  chooseAppDescription,
+  choosePackageManager,
+  chooseTestPlugins,
+  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);
+  }
+}
+
+export default action('Global prompts', globalPrompts, { startSpinner: false });

package/lib/scaffold/actions/index.js

@@ -0,0 +1,33 @@
+import mkDir from './mkdir.js';
+import loadPreset from './load-preset.js';
+import globalPrompts from './global-prompts.js';
+import setupPkg from './setup-pkg.js';
+import writePkg from './write-pkg.js';
+import installModules from './install-modules.js';
+import linkModules from './link-modules.js';
+import writeGasketConfig from './write-gasket-config.js';
+import presetPromptHooks from './preset-prompt-hooks.js';
+import presetConfigHooks from './preset-config-hooks.js';
+import promptHooks from './prompt-hooks.js';
+import createHooks from './create-hooks.js';
+import generateFiles from './generate-files.js';
+import postCreateHooks from './post-create-hooks.js';
+import printReport from './print-report.js';
+
+export {
+  mkDir,
+  loadPreset,
+  globalPrompts,
+  setupPkg,
+  writePkg,
+  installModules,
+  linkModules,
+  writeGasketConfig,
+  presetPromptHooks,
+  presetConfigHooks,
+  promptHooks,
+  createHooks,
+  postCreateHooks,
+  generateFiles,
+  printReport
+};

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

@@ -0,0 +1,15 @@
+import action from '../action-wrapper.js';
+
+/**
+ * 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();
+}
+
+export default action('Install node modules', installModules);

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

@@ -0,0 +1,19 @@
+import action from '../action-wrapper.js';
+
+/**
+ * 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);
+  }
+}
+
+export default action('Link node modules', linkModules, { startSpinner: false });

package/lib/scaffold/actions/load-preset.js

@@ -0,0 +1,60 @@
+import path from 'path';
+import os from 'os';
+import action from '../action-wrapper.js';
+import { default as gasketUtils } from '@gasket/utils';
+import { mkdtemp } from 'fs/promises';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const hasVersion = /@(\^[0-9]\.|[0-9]).+/;
+
+/**
+ * loadPresets - Load presets to temp directory
+ * @param {CreateContext} context - Create context
+ */
+async function loadPresets({ context }) {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), `gasket-create-${context.appName}`));
+  context.tmpDir = tmpDir;
+
+  const modPath = path.join(tmpDir, 'node_modules');
+  const pkgManager = new gasketUtils.PackageManager({
+    packageManager: context.packageManager,
+    dest: tmpDir
+  });
+  const pkgVerb = pkgManager.manager === 'yarn' ? 'add' : 'install';
+
+  const remotePresets = context.rawPresets.map(async preset => {
+    const parts = hasVersion.test(preset) && preset.split('@').filter(Boolean);
+    const name = parts ? `@${parts[0]}` : preset;
+    const version = parts ? `@${parts[1]}` : '@latest';
+
+    try {
+      // Install the preset
+      await pkgManager.exec(pkgVerb, [`${name}${version}`]);
+      // Get the package file
+      const pkgFile = require(path.join(modPath, name, 'package.json'));
+      // Import the preset via the package file attrs, name and main
+      // We can't specify the cwd for the import, so we need to use the full path
+      // expects type:module & "main": "lib/fullpath.js"
+      const mod = await import(`${modPath}/${name}/${pkgFile.main}`);
+      return mod.default || mod;
+    } catch (err) {
+      throw new Error(`Failed to install preset ${name}${version}`);
+    }
+  });
+
+  const localPresets = context.localPresets.map(async localPresetPath => {
+
+    try {
+      await pkgManager.exec(pkgVerb, [localPresetPath]);
+      const pkgFile = require(path.join(localPresetPath, 'package.json'));
+      const mod = await import(`${modPath}/${pkgFile.name}/${pkgFile.main}`);
+      return mod.default || mod;
+    } catch (err) {
+      throw new Error(`Failed to install local preset ${localPresetPath}`);
+    }
+  });
+
+  context.presets = await Promise.all([...remotePresets, ...localPresets]);
+}
+
+export default action('Load presets', loadPresets);

package/lib/scaffold/actions/mkdir.js

@@ -0,0 +1,30 @@
+import { mkdir } from 'fs/promises';
+import action from '../action-wrapper.js';
+
+/**
+ * Validates this instance can execute without common blockers:
+ *   - Target destination on disk is available. Validate by acquiring
+ *     a lock through `mkdir`.
+ *
+ * @param {CreateContext} context - Create context
+ * @param {Spinner} spinner - Spinner
+ * @returns {Promise} promise
+ */
+async function mkDir({ context, spinner }) {
+  const { dest, relDest, extant, destOverride } = context;
+
+  // At this point, either the directory does not exist, or the user has
+  // confirmed that this directory can be overwritten, so we can proceed.
+
+  if (!extant) {
+    spinner.text = `Make directory: ${relDest}`;
+    await mkdir(dest);
+  } else {
+    spinner.text = `Existing directory: ${relDest}`;
+    if (!destOverride) {
+      throw new Error(`Directory ${relDest} was not allowed to be overwritten.`);
+    }
+  }
+}
+
+export default action('Set up directory', mkDir);

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

@@ -0,0 +1,31 @@
+import action from '../action-wrapper.js';
+import { runShellCommand } from '@gasket/utils';
+
+/**
+ * Executes the `postCreate` hook for all registered plugins.
+ *
+ * @param {GasketEngine} gasket - Gasket API
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+async function postCreateHooks({ gasket, context }) {
+  const { dest } = context;
+
+  /**
+   * Run an npm script in the context of the created application
+   * @param  {String} script name of script
+   * @returns {Promise} A promise represents if npm succeeds or fails.
+   */
+  async function runScript(script) {
+    return await runShellCommand('npm', ['run', script], { cwd: dest });
+  }
+
+  /**
+   * An object with one value for now, so adding more utilities
+   * in future is easy.
+   */
+  const utils = { runScript };
+  await gasket.exec('postCreate', context, utils);
+}
+
+export default action('Execute postCreate hooks', postCreateHooks);

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

@@ -0,0 +1,13 @@
+import action from '../action-wrapper.js';
+
+/**
+ * presetConfigHooks - exec `presetConfig` hook
+ * @param {Gasket} gasket - Preset gasket instance
+ * @param {CreateContext} context - Create context
+ */
+async function presetConfigHooks({ gasket, context }) {
+  const config = await gasket.execWaterfall('presetConfig', context);
+  Object.assign(context.presetConfig, config);
+}
+
+export default action('Preset Config', presetConfigHooks, { startSpinner: false });

package/lib/scaffold/actions/preset-prompt-hooks.js

@@ -0,0 +1,17 @@
+import inquirer from 'inquirer';
+import action from '../action-wrapper.js';
+
+/**
+ * presetPromptHooks - exec `presetPrompt` hook
+ * @param {Gasket} gasket - Preset gasket instance
+ * @param {CreateContext} context - Create context
+ */
+async function presetPromptHooks({ gasket, context }) {
+  const prompt = context.prompts ? inquirer.createPromptModule() : () => ({});
+
+  const nextContext = await gasket.execWaterfall('presetPrompt', context, { prompt });
+
+  Object.assign(context, nextContext);
+}
+
+export default action('Preset prompts', presetPromptHooks, { startSpinner: false });