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

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

@@ -0,0 +1,89 @@
+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
+ * @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
+ */
+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
+` + logo);
+
+  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();
+}
+
+export default action('Print report', printReport, { startSpinner: false });

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

@@ -0,0 +1,43 @@
+import inquirer from 'inquirer';
+import action from '../action-wrapper.js';
+
+/**
+ * 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(gasket, context) {
+  //
+  // @see: https://github.com/SBoudrias/Inquirer.js/#inquirercreatepromptmodule---prompt-function
+  //
+  const prompt = context.prompts ? inquirer.createPromptModule() : () => ({});
+  const nextContext = await gasket.execWaterfall('prompt', context, { prompt });
+  //
+  // 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` util function for prompting features.
+ *
+ * @param {GasketEngine} gasket - Gasket API
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+async function promptHooks({ gasket, context }) {
+  //
+  // Because `execPluginPrompts` is recursively, we need to start it
+  // with the processPlugins and presets from our initial context
+  //
+  const { plugins } = context;
+  await execPluginPrompts(gasket, context, plugins);
+}
+
+export default action('Plugin prompts', promptHooks, { startSpinner: false });

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

@@ -0,0 +1,34 @@
+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.
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+async function setupPkg({ context }) {
+  const { appName, appDescription, warnings } = context;
+
+  const pkg = ConfigBuilder.createPackageJson({
+    name: appName,
+    version: '0.0.0',
+    description: appDescription,
+    type: 'module'
+  }, { warnings });
+
+  // Add critical dependencies
+  pkg.add('dependencies', {
+    '@gasket/core': dependencies['@gasket/core'],
+    '@gasket/utils': dependencies['@gasket/utils']
+  });
+
+  const pkgManager = new gasketUtils.PackageManager(context);
+  Object.assign(context, { pkg, pkgManager });
+}
+
+export default action('Set up package.json', setupPkg, { startSpinner: false });

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

@@ -0,0 +1,117 @@
+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.
+ *
+ * @param {CreateContext} context - Create context
+ * @returns {Promise} promise
+ */
+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';
+
+  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);
+
+  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);
+}
+
+export default action('Write gasket config', writeGasketConfig);

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

@@ -0,0 +1,19 @@
+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
+ * @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);
+}
+
+export default action('Write package.json', writePkg);