create-gasket-app 7.0.0-next.2 → 7.0.0-next.21

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

@@ -1,4 +1,4 @@
-const action = require('../action-wrapper');
+import action from '../action-wrapper.js';
 
 /**
  * Installs node_modules using the selected package manager
@@ -6,13 +6,10 @@ const action = require('../action-wrapper');
  * @param {CreateContext} context - Create context
  * @returns {Promise} promise
  */
-async function installModules(context) {
+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);
+export default action('Install node modules', installModules);

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

@@ -1,4 +1,4 @@
-const action = require('../action-wrapper');
+import action from '../action-wrapper.js';
 
 /**
  * Links local packages using the selected package manager
@@ -7,7 +7,7 @@ const action = require('../action-wrapper');
  * @param {Spinner} spinner - Spinner
  * @returns {Promise} promise
  */
-async function linkModules(context, spinner) {
+async function linkModules({ context, spinner }) {
   const { pkgLinks, pkgManager } = context;
 
   if (pkgLinks && pkgLinks.length) {
@@ -16,6 +16,4 @@ async function linkModules(context, spinner) {
   }
 }
 
-module.exports = action('Link node modules', linkModules, { startSpinner: false });
-
-module.exports.update = action('Relink node modules', linkModules, { startSpinner: false });
+export default action('Link node modules', linkModules, { startSpinner: false });

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

@@ -1,82 +1,60 @@
-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;
-}
+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]).+/;
 
 /**
- * Loads PresetInfo from local preset package
- *
+ * loadPresets - Load presets to temp directory
  * @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);
+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.isYarn ? '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}`);
+    }
   });
 
-  return presetInfos;
-}
+  const localPresets = context.localPresets.map(async localPresetPath => {
 
-/**
- * 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));
+    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}`);
+    }
+  });
 
-  const presets = presetInfos.map(p => presetIdentifier(p.rawName).shortName);
-  Object.assign(context, { presets, presetInfos });
+  context.presets = await Promise.all([...remotePresets, ...localPresets]);
 }
 
-module.exports = action('Load presets', loadPreset);
+export default action('Load presets', loadPresets);

package/lib/scaffold/actions/mkdir.js

@@ -1,5 +1,5 @@
-const { mkdir } = require('fs').promises;
-const action = require('../action-wrapper');
+import { mkdir } from 'fs/promises';
+import action from '../action-wrapper.js';
 
 /**
  * Validates this instance can execute without common blockers:
@@ -10,7 +10,7 @@ const action = require('../action-wrapper');
  * @param {Spinner} spinner - Spinner
  * @returns {Promise} promise
  */
-async function mkDir(context, spinner) {
+async function mkDir({ context, spinner }) {
   const { dest, relDest, extant, destOverride } = context;
 
   // At this point, either the directory does not exist, or the user has
@@ -27,4 +27,4 @@ async function mkDir(context, spinner) {
   }
 }
 
-module.exports = action('Set up directory', mkDir);
+export default action('Set up directory', mkDir);

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

@@ -1,15 +1,15 @@
-const action = require('../action-wrapper');
-const createEngine = require('../create-engine');
-const { runShellCommand } = require('@gasket/utils');
+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(context) {
-  const { dest, presets = [], plugins = [] } = context;
+async function postCreateHooks({ gasket, context }) {
+  const { dest } = context;
 
   /**
    * Run an npm script in the context of the created application
@@ -25,9 +25,7 @@ async function postCreateHooks(context) {
    * 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);
+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 });

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

@@ -1,6 +1,7 @@
-const { bold } = require('chalk');
-const action = require('../action-wrapper');
-const asciiLogo = require('../../utils/logo');
+import pkg from 'chalk';
+const { bold } = pkg;
+import action from '../action-wrapper.js';
+import { logo } from '../../utils/index.js';
 
 /**
  * Logs a new line in the console
@@ -62,14 +63,14 @@ function buildReport(context) {
 
  * @param {CreateContext} context - Create context
  */
-function printReport(context) {
+async 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);
+` + logo);
 
   Object.entries(report).forEach(([k, v]) => {
     if (!v || !v.length) return;
@@ -85,4 +86,4 @@ Finished with ${warnings.length} warnings and ${errors.length} errors using
   newline();
 }
 
-module.exports = action('Print report', printReport, { startSpinner: false });
+export default action('Print report', printReport, { startSpinner: false });

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

@@ -1,47 +1,5 @@
-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));
-  };
-};
+import inquirer from 'inquirer';
+import action from '../action-wrapper.js';
 
 /**
  * Initializes engine with provide preset and plugins
@@ -53,18 +11,12 @@ const createAddPlugins = context => {
  * @returns {Promise} promise
  * @private
  */
-async function execPluginPrompts(context, plugins = [], presets = []) {
-  const { dest } = context;
-
-  const gasket = await createEngine({ dest, presets, plugins });
-
+async function execPluginPrompts(gasket, context) {
   //
   // @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 });
+  const nextContext = await gasket.execWaterfall('prompt', context, { prompt });
   //
   // Ensure the original context is transformed in case a prompt returns a new object
   //
@@ -73,18 +25,19 @@ async function execPluginPrompts(context, plugins = [], presets = []) {
 
 /**
  * Executes the `prompt` hook for all registered plugins.
- * Adds `prompt` and `addPlugins` util functions for prompting features.
+ * Adds `prompt` util function for prompting features.
  *
+ * @param {GasketEngine} gasket - Gasket API
  * @param {CreateContext} context - Create context
  * @returns {Promise} promise
  */
-async function promptHooks(context) {
+async function promptHooks({ gasket, 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);
+  const { plugins } = context;
+  await execPluginPrompts(gasket, context, plugins);
 }
 
-module.exports = action('Plugin prompts', promptHooks, { startSpinner: false });
+export default action('Plugin prompts', promptHooks, { startSpinner: false });

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

@@ -1,9 +1,9 @@
-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');
+import action from '../action-wrapper.js';
+import { ConfigBuilder } from '../config-builder.js';
+import { default as gasketUtils } from '@gasket/utils';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const { dependencies } = require('../../../package.json');
 
 /**
  * Initializes the ConfigBuilder builder and adds to context.
@@ -11,37 +11,25 @@ const { devDependencies } = require('../../../package');
  * @param {CreateContext} context - Create context
  * @returns {Promise} promise
  */
-async function setupPkg(context) {
-  const { appName, appDescription, presetInfos = [], rawPlugins = [], cliVersionRequired, warnings } = context;
+async function setupPkg({ context }) {
+  const { appName, appDescription, warnings } = context;
 
   const pkg = ConfigBuilder.createPackageJson({
     name: appName,
     version: '0.0.0',
-    description: appDescription
+    description: appDescription,
+    type: context.typescript ? 'commonjs' : 'module'
   }, { 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
+  // Add critical dependencies
+  pkg.add('dependencies', {
+    '@gasket/core': dependencies['@gasket/core'],
+    '@gasket/engine': dependencies['@gasket/engine'],
+    '@gasket/utils': dependencies['@gasket/utils']
   });
 
-  const pkgManager = new PackageManager(context);
-  const pluginIds = await getPluginsWithVersions(rawPlugins, pkgManager);
-  addPluginsToPkg(pluginIds, pkg);
-
+  const pkgManager = new gasketUtils.PackageManager(context);
   Object.assign(context, { pkg, pkgManager });
 }
 
-module.exports = action('Set up package.json', setupPkg, { startSpinner: false });
+export default action('Set up package.json', setupPkg, { startSpinner: false });

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

@@ -1,7 +1,86 @@
-const JSON5 = require('json5');
-const path = require('path');
-const { writeFile } = require('fs').promises;
-const action = require('../action-wrapper');
+import { default as JSON5 } from 'json5';
+import path from 'path';
+import { writeFile } from 'fs/promises';
+import action from '../action-wrapper.js';
+
+/**
+ * writePluginImports - Write string imports as value(s)
+ * @param {string[]} plugins - Array of plugin import names
+ * @returns {string} - Array of plugin imports as string
+ */
+function writePluginImports(plugins) {
+  return plugins.reduce((acc, cur, index) => {
+    acc += `\t\t${cur}${index < plugins.length - 1 ? ',\n' : ''}`;
+    return acc;
+  }, '');
+}
+
+/**
+ * writeImports - Write imports to file using key value pairs
+ * @param {{[pluginImport: string]: string}[]} imports - Array of key value pairs for imports
+ * @returns {string} - import declarations as string
+ */
+function writeImports(imports) {
+  if (!imports) return '';
+  return `${Object.entries(imports).map(([importDef, importPath]) => `import ${importDef} from '${importPath}';`).join('\n')}\n`;
+}
+
+/**
+ * createInjectionAssignments - replace object path with a temp string value
+ * @param {GasketConfigDefinition} config - gasket config object
+ * @param {{ [configKey]: string }} assignments - key value pairs of config keys to replace
+ * @returns {string} - string if assignments is falsy
+ */
+function createInjectionAssignments(config, assignments) {
+  if (!assignments) return '';
+  Object.keys(assignments).forEach((key) => {
+    const keys = key.split('.');
+
+    keys.reduce((acc, cur, index) => {
+      if (index === keys.length - 1) {
+        acc[cur] = `${key}_INJECTION_ASSIGNMENT_REPLACE`;
+        return;
+      }
+      return acc[cur];
+    }, config);
+  });
+}
+
+/**
+ * replaceInjectionAssignments - replace temp string value with actual value
+ * @param {string} content
+ * @param {{ [configKey]: string }} assignments - key value pairs of config keys to replace
+ * @returns {string} - content with replaced values
+ */
+function replaceInjectionAssignments(content, assignments) {
+  if (!assignments) return content;
+  Object.keys(assignments).forEach((key) => {
+    content = content.replace(`'${key}_INJECTION_ASSIGNMENT_REPLACE'`, assignments[key]);
+  });
+
+  return content;
+}
+
+/**
+ * writeExpressions - Write expressions to file
+ * @param {string} expressions - programmatic expressions as string
+ * @returns {string} - expressions as string
+ */
+function writeExpressions(expressions) {
+  if (!expressions) return '';
+  return `${expressions.map((expression) => `${expression}`).join('\n')}\n`;
+}
+
+/**
+ * cleanupFields - Remove fields from config object
+ * @param {GasketConfigDefinition} config - gasket config object
+ */
+function cleanupFields(config) {
+  delete config.fields.imports;
+  delete config.fields.pluginImports;
+  delete config.fields.expressions;
+  delete config.fields.injectionAssignments;
+}
 
 /**
  * Writes the contents of `pkg` to the app's package.json.
@@ -9,24 +88,30 @@ const action = require('../action-wrapper');
  * @param {CreateContext} context - Create context
  * @returns {Promise} promise
  */
-async function writeGasketConfig(context) {
-  const { dest, gasketConfig, presets, plugins, generatedFiles } = context;
-  const fileName = 'gasket.config.js';
+async function writeGasketConfig({ context }) {
+  const { dest, gasketConfig, generatedFiles } = context;
+  const fileName = context.typescript ? 'gasket.ts' : 'gasket.js';
   const filePath = path.join(dest, fileName);
+  const plugins = gasketConfig.fields.plugins;
+  const assignments = gasketConfig.fields.injectionAssignments || null;
+  const expressions = gasketConfig.fields.expressions || null;
+  gasketConfig.fields.plugins = 'PLUGIN_REPLACE';
 
-  gasketConfig.add('plugins', {
-    presets,
-    ...(plugins && plugins.length ? { add: plugins } : {})
-  });
+  let contents = '';
+  contents += `import { makeGasket } from '@gasket/core';\n`;
+  contents += writeImports(gasketConfig.fields.pluginImports);
+  contents += writeImports(gasketConfig.fields.imports);
+  contents += writeExpressions(expressions);
+  createInjectionAssignments(gasketConfig.fields, assignments);
+  cleanupFields(gasketConfig);
 
-  //
-  // Use JSON5 to stringify the config and add export for CommonJS
-  //
-  const contents = 'module.exports = ' +
-    JSON5.stringify(gasketConfig, null, 2) + ';\n';
+  const pluginImports = `[\n${writePluginImports(plugins)}\n\t]`;
+  contents += `\nexport default makeGasket(${JSON5.stringify(gasketConfig.fields, null, 2)});\n`;
+  contents = contents.replace('\'PLUGIN_REPLACE\'', pluginImports);
+  contents = replaceInjectionAssignments(contents, assignments);
 
   await writeFile(filePath, contents, 'utf8');
   generatedFiles.add(fileName);
 }
 
-module.exports = action('Write gasket config', writeGasketConfig);
+export default action('Write gasket config', writeGasketConfig);

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

@@ -1,23 +1,19 @@
-const path = require('path');
-const { writeFile } = require('fs').promises;
-const action = require('../action-wrapper');
+import path from 'path';
+import { writeFile } from 'fs/promises';
+import action from '../action-wrapper.js';
 
 /**
  * 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) {
+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);
+export default action('Write package.json', writePkg);