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

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

@@ -0,0 +1,82 @@
+const path = require('path');
+const action = require('../action-wrapper');
+const PackageFetcher = require('../fetcher');
+const { presetIdentifier, Loader } = require('@gasket/resolve');
+
+const loader = new Loader();
+
+/**
+ * Fetches the preset packages and loads PresetInfos
+ *
+ * @param {[String]} rawPresets - Presets names
+ * @param {String} cwd - Root path
+ * @param {String} from from
+ * @returns {PresetInfo[]} loaded presetInfos
+ * @private
+ */
+async function remotePresets(rawPresets, cwd, from) {
+  if (!rawPresets) { return []; }
+
+  const allRemotePresets = await Promise.all(rawPresets.map(async rawName => {
+    const packageName = presetIdentifier(rawName).full;
+    const fetcher = new PackageFetcher({ cwd, packageName });
+    const pkgPath = await fetcher.clone();
+
+    const presetInfo = loader.loadPreset(pkgPath, { from: from, rawName }, { shallow: true });
+    const { name: presetName, dependencies } = presetInfo.package;
+    if (!dependencies) {
+      return presetInfo;
+    }
+
+    const presetDeps = Object.keys(dependencies).filter(k => presetIdentifier.isValidFullName(k));
+    const rawPresetsDeps = presetDeps.map(presetDep => `${presetDep}@${dependencies[presetDep]}`);
+
+    const presetInfoDeps = await remotePresets(rawPresetsDeps, cwd, presetName);
+    return {
+      ...presetInfo,
+      presets: presetInfoDeps
+    };
+  }));
+
+  return allRemotePresets;
+}
+
+/**
+ * Loads PresetInfo from local preset package
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {PresetInfo[]} loaded presetInfos
+ * @private
+ */
+function localPreset(context) {
+  const { cwd, localPresets = [] } = context;
+  if (!localPresets) { return []; }
+
+  const presetInfos = [];
+  localPresets.forEach(localPresetPath => {
+    const pkgPath = path.resolve(cwd, localPresetPath);
+    const presetInfo = loader.loadPreset(pkgPath, { from: 'cli' }, { shallow: false });
+    presetInfo.rawName = `${presetInfo.package.name}@file:${pkgPath}`;
+    presetInfos.push(presetInfo);
+  });
+
+  return presetInfos;
+}
+
+/**
+ * Downloads the target preset package and adds the package.json
+ * contents and plugins dependencies to context.
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+async function loadPreset(context) {
+  const { rawPresets = [], cwd } = context;
+  let presetInfos = await remotePresets(rawPresets, cwd, 'cli');
+  presetInfos = presetInfos.concat(localPreset(context));
+
+  const presets = presetInfos.map(p => presetIdentifier(p.rawName).shortName);
+  Object.assign(context, { presets, presetInfos });
+}
+
+module.exports = action('Load presets', loadPreset);

package/lib/scaffold/actions/mkdir.js

@@ -0,0 +1,30 @@
+const { mkdir } = require('fs').promises;
+const action = require('../action-wrapper');
+
+/**
+ * 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.`);
+    }
+  }
+}
+
+module.exports = action('Set up directory', mkDir);

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

@@ -0,0 +1,33 @@
+const action = require('../action-wrapper');
+const createEngine = require('../create-engine');
+const { runShellCommand } = require('@gasket/utils');
+
+/**
+ * Executes the `postCreate` hook for all registered plugins.
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+async function postCreateHooks(context) {
+  const { dest, presets = [], plugins = [] } = 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 };
+
+  const gasket = await createEngine({ dest, presets, plugins });
+  await gasket.exec('postCreate', context, utils);
+}
+
+module.exports = action('Execute postCreate hooks', postCreateHooks);

package/lib/scaffold/actions/print-report.js

@@ -0,0 +1,88 @@
+const { bold } = require('chalk');
+const action = require('../action-wrapper');
+const asciiLogo = require('../../utils/logo');
+
+/**
+ * Logs a new line in the console
+ * @private
+ */
+const newline = () => {
+  console.log('');
+};
+
+/**
+ * Converts a camelCase string to Space Case
+ * @see: https://stackoverflow.com/questions/4149276/javascript-camelcase-to-regular-form?answertab=active#tab-top
+ *
+ * @param {string} str - camelCase string to fixup
+ * @returns {string} result
+ * @private
+ */
+const toSpaceCase = str => str.replace(/([A-Z])/g, ' $1')
+  .replace(/^./, s => s.toUpperCase());
+
+/**
+ * Builds the report object from context
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {Object} report
+ * @private
+ */
+function buildReport(context) {
+  const {
+    appName,
+    dest,
+    fullPresets,
+    plugins,
+    generatedFiles: generatedFilesSet,
+    messages,
+    warnings,
+    errors,
+    nextSteps
+  } = context;
+
+  const generatedFiles = Array.from(generatedFilesSet);
+  generatedFiles.sort();
+
+  return {
+    appName,
+    output: dest,
+    presets: fullPresets,
+    plugins,
+    generatedFiles,
+    messages,
+    warnings,
+    errors,
+    nextSteps
+  };
+}
+
+/**
+ * Outputs create command details to the console
+
+ * @param {CreateContext} context - Create context
+ */
+function printReport(context) {
+  const report = buildReport(context);
+  const { warnings, errors } = context;
+
+  console.log(`✨Success!
+  
+Finished with ${warnings.length} warnings and ${errors.length} errors using
+` + asciiLogo);
+
+  Object.entries(report).forEach(([k, v]) => {
+    if (!v || !v.length) return;
+    newline();
+    console.log(`${bold(toSpaceCase(k))}`);
+    if (Array.isArray(v)) {
+      v.map(o => console.log(`  ${o}`));
+    } else {
+      console.log(`  ${v}`);
+    }
+  });
+
+  newline();
+}
+
+module.exports = action('Print report', printReport, { startSpinner: false });

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

@@ -0,0 +1,90 @@
+const inquirer = require('inquirer');
+const action = require('../action-wrapper');
+const { addPluginsToContext, addPluginsToPkg, getPluginsWithVersions } = require('../utils');
+const createEngine = require('../create-engine');
+
+/**
+ * Create the `addPlugins` function with context
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {addPlugins} addPlugins
+ */
+const createAddPlugins = context => {
+  /**
+   * Allows plugins to add plugins based on user input.
+   *
+   * @typedef {Function} addPlugins
+   *
+   * @param {...PluginDesc} pluginsToAdd - Additional plugins to add
+   * @returns {Promise} promise
+   */
+  return async function addPlugins(...pluginsToAdd) {
+    const { pkg, pkgLinks = [], pkgManager } = context;
+
+    addPluginsToContext(pluginsToAdd, context);
+    const pluginIds = await getPluginsWithVersions(pluginsToAdd, pkgManager);
+    addPluginsToPkg(pluginIds, pkg);
+
+    //
+    // Install new plugins if not already linked
+    //
+    const toInstall = pluginIds.filter(p => !pkgLinks.includes(p.fullName));
+    if (toInstall.length) {
+      await pkgManager.install(toInstall.map(p => p.full));
+      //
+      // relink because npm blows them away on installs...
+      //
+      if (pkgLinks.length) {
+        await pkgManager.link(pkgLinks);
+      }
+    }
+
+    await execPluginPrompts(context, pluginIds.map(p => p.shortName));
+  };
+};
+
+/**
+ * Initializes engine with provide preset and plugins
+ * to execute their prompt lifecycle hooks.
+ *
+ * @param {CreateContext} context - Create context
+ * @param {String[]} plugins - plugins to load
+ * @param {String} [presets] - presets to load
+ * @returns {Promise} promise
+ * @private
+ */
+async function execPluginPrompts(context, plugins = [], presets = []) {
+  const { dest } = context;
+
+  const gasket = await createEngine({ dest, presets, plugins });
+
+  //
+  // @see: https://github.com/SBoudrias/Inquirer.js/#inquirercreatepromptmodule---prompt-function
+  //
+  const prompt = context.prompts ? inquirer.createPromptModule() : () => ({});
+  const addPlugins = createAddPlugins(context);
+
+  const nextContext = await gasket.execWaterfall('prompt', context, { prompt, addPlugins });
+  //
+  // Ensure the original context is transformed in case a prompt returns a new object
+  //
+  Object.assign(context, nextContext);
+}
+
+/**
+ * Executes the `prompt` hook for all registered plugins.
+ * Adds `prompt` and `addPlugins` util functions for prompting features.
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+async function promptHooks(context) {
+  //
+  // Because `execPluginPrompts` is recursively, we need to start it
+  // with the processPlugins and presets from our initial context
+  //
+  const { presets, plugins } = context;
+  await execPluginPrompts(context, plugins, presets);
+}
+
+module.exports = action('Plugin prompts', promptHooks, { startSpinner: false });

package/lib/scaffold/actions/setup-pkg.js

@@ -0,0 +1,47 @@
+const action = require('../action-wrapper');
+const ConfigBuilder = require('../config-builder');
+const { addPluginsToPkg, getPluginsWithVersions } = require('../utils');
+const { PackageManager } = require('@gasket/utils');
+const { presetIdentifier } = require('@gasket/resolve');
+const { devDependencies } = require('../../../package');
+
+/**
+ * Initializes the ConfigBuilder builder and adds to context.
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+async function setupPkg(context) {
+  const { appName, appDescription, presetInfos = [], rawPlugins = [], cliVersionRequired, warnings } = context;
+
+  const pkg = ConfigBuilder.createPackageJson({
+    name: appName,
+    version: '0.0.0',
+    description: appDescription
+  }, { warnings });
+
+  // The preset package itself must be included in the dependencies
+  // of the `pkg` to be bootstrapped.
+  pkg.add('dependencies', presetInfos.reduce((acc, presetInfo) => {
+    // Use rawName in case version or file path was set in cli args
+    // Otherwise fallback to resolved version
+    const { fullName, version } = presetIdentifier(presetInfo.rawName).withVersion(`^${presetInfo.version}`);
+
+    acc[fullName] = version;
+    return acc;
+  }, {
+    '@gasket/cli': cliVersionRequired
+  }));
+
+  pkg.add('depencencies', {
+    dotenv: devDependencies.dotenv
+  });
+
+  const pkgManager = new PackageManager(context);
+  const pluginIds = await getPluginsWithVersions(rawPlugins, pkgManager);
+  addPluginsToPkg(pluginIds, pkg);
+
+  Object.assign(context, { pkg, pkgManager });
+}
+
+module.exports = action('Set up package.json', setupPkg, { startSpinner: false });

package/lib/scaffold/actions/write-gasket-config.js

@@ -0,0 +1,32 @@
+const JSON5 = require('json5');
+const path = require('path');
+const { writeFile } = require('fs').promises;
+const action = require('../action-wrapper');
+
+/**
+ * Writes the contents of `pkg` to the app's package.json.
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+async function writeGasketConfig(context) {
+  const { dest, gasketConfig, presets, plugins, generatedFiles } = context;
+  const fileName = 'gasket.config.js';
+  const filePath = path.join(dest, fileName);
+
+  gasketConfig.add('plugins', {
+    presets,
+    ...(plugins && plugins.length ? { add: plugins } : {})
+  });
+
+  //
+  // Use JSON5 to stringify the config and add export for CommonJS
+  //
+  const contents = 'module.exports = ' +
+    JSON5.stringify(gasketConfig, null, 2) + ';\n';
+
+  await writeFile(filePath, contents, 'utf8');
+  generatedFiles.add(fileName);
+}
+
+module.exports = action('Write gasket config', writeGasketConfig);

package/lib/scaffold/actions/write-pkg.js

@@ -0,0 +1,23 @@
+const path = require('path');
+const { writeFile } = require('fs').promises;
+const action = require('../action-wrapper');
+
+/**
+ * Writes the contents of `pkg` to the app's package.json.
+ *
+ * @param {CreateContext} context - Create context
+ * @param {Boolean} update - Is an update step
+ * @returns {Promise} promise
+ */
+async function writePkg(context) {
+  const { dest, pkg, generatedFiles } = context;
+  const fileName = 'package.json';
+  const filePath = path.join(dest, fileName);
+
+  await writeFile(filePath, JSON.stringify(pkg, null, 2), 'utf8');
+  generatedFiles.add(fileName);
+}
+
+module.exports = action('Write package.json', writePkg);
+
+module.exports.update = action('Update package.json', writePkg);