create-gasket-app 7.0.0-next.4 → 7.0.0-next.41

package/lib/commands/create.js

@@ -1,4 +1,4 @@
-/* eslint-disable max-statements */
+/* eslint-disable max-statements, no-unused-vars */
 import chalk from 'chalk';
 import { makeCreateContext } from '../scaffold/create-context.js';
 import { dumpErrorContext } from '../scaffold/dump-error-context.js';
@@ -87,51 +87,62 @@ const createCommand = {
       conflicts: ['config']
     },
     {
-      name: 'prompts',
+      name: 'no-prompts',
       description: '(INTERNAL) Disable to skip the prompts',
-      default: true,
       type: 'boolean',
       hidden: true
     }
   ]
 };
 
+/**
+ * createCommand action
+ * @param {string} appname Required cmd arg - name of the app to create
+ * @param {object} options cmd options
+ * @param {Command} command - the command instance
+ * @returns {Promise<void>} void
+ */
 createCommand.action = async function run(appname, options, command) {
+  process.env.GASKET_ENV = 'create';
   const context = makeCreateContext([appname], options);
+  const { rawPresets, localPresets } = context;
 
   try {
-    await loadPreset(null, context);
-    await globalPrompts(null, context);
+    await globalPrompts({ context });
 
-    const presetGasket = makeGasket({
-      plugins: context.presets
-    });
+    if (rawPresets.length || localPresets.length) {
+      await loadPreset({ context });
 
-    await presetPromptHooks(presetGasket, context);
-    await presetConfigHooks(presetGasket, context);
+      const presetGasket = makeGasket({
+        plugins: context.presets
+      });
+
+      await presetPromptHooks({ gasket: presetGasket, context });
+      await presetConfigHooks({ gasket: presetGasket, context });
+    }
 
     const pluginGasket = makeGasket({
       ...context.presetConfig,
       plugins: context.presets.concat(context.presetConfig.plugins, defaultPlugins)
     });
 
-    await promptHooks(pluginGasket, context);
-    await mkDir(null, context);
-    await setupPkg(null, context);
-    await createHooks(pluginGasket, context);
-    await writePkg(null, context);
-    await generateFiles(null, context);
-    await writeGasketConfig(null, context);
-    await installModules(null, context);
-    await linkModules(null, context);
-    await postCreateHooks(pluginGasket, context);
-    await rm(context.tmpDir, { recursive: true });
-    printReport(context);
+    await promptHooks({ gasket: pluginGasket, context });
+    await mkDir({ context });
+    await setupPkg({ context });
+    await createHooks({ gasket: pluginGasket, context });
+    await writePkg({ context });
+    await generateFiles({ context });
+    await writeGasketConfig({ context });
+    await installModules({ context });
+    await linkModules({ context });
+    await postCreateHooks({ gasket: pluginGasket, context });
+    if (context.tmpDir) await rm(context.tmpDir, { recursive: true });
+    printReport({ context });
   } catch (err) {
     console.error(chalk.red('Exiting with errors.'));
     dumpErrorContext(context, err);
     throw err;
   }
-}
+};
 
 export { createCommand };

package/lib/config/default-plugins.js

@@ -1,7 +1,15 @@
 import pluginGit from '@gasket/plugin-git';
 import pluginLogger from '@gasket/plugin-logger';
+import pluginMetadata from '@gasket/plugin-metadata';
+import pluginCommand from '@gasket/plugin-command';
+import pluginDocs from '@gasket/plugin-docs';
+import pluginDocusaurus from '@gasket/plugin-docusaurus';
 
 export const defaultPlugins = [
   pluginLogger,
-  pluginGit
+  pluginGit,
+  pluginMetadata,
+  pluginCommand,
+  pluginDocs,
+  pluginDocusaurus
 ];

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import type { GasketConfigDefinition, MaybeAsync } from '@gasket/engine';
+import type { GasketConfigDefinition, MaybeAsync, Plugin, GasketEngine } from '@gasket/core';
 import type { PackageManager } from '@gasket/utils';
 
 export interface Dependencies {
@@ -9,17 +9,18 @@ export interface Dependencies {
 
 export interface PackageJson extends Dependencies {
   name: string;
-  version: string;
+  version?: string;
   description?: string;
   license?: string;
   repository?:
   | string
   | {
-    type: 'git';
-    url: string;
-  };
+        type: 'git';
+        url: string;
+      };
   scripts?: Record<string, string>;
   optionalDependencies?: Record<string, string>;
+  homepage?: string;
 }
 
 export interface ModuleInfo {
@@ -30,11 +31,9 @@ export interface ModuleInfo {
   version?: string;
 }
 
-export interface PresetInfo extends ModuleInfo {
-}
+export interface PresetInfo extends ModuleInfo {}
 
-export interface PluginInfo extends ModuleInfo {
-}
+export interface PluginInfo extends ModuleInfo {}
 
 export interface ConfigBuilder<Config> {
   /**
@@ -63,25 +62,85 @@ export interface ConfigBuilder<Config> {
     options?: { force?: boolean }
   ): void;
 
-  // TODO Document
+  /**
+   * addPlugin - Add plugin import to the gasket file and use the value in the plugins array
+   * @param {string} pluginImport - name of the import used as a value - `import pluginImport...`
+   * @param {string} pluginName - name of the plugin import/package - `from 'pluginName'`
+   * @example
+   * addPlugin('pluginA', '@gasket/plugin-a')
+   *
+   * // gasket.js
+   * import pluginA from '@gasket/plugin-a';
+   *
+   * export default makeGasket({
+   *  plugins: [
+   *    pluginA
+   *  ]
+   * });
+   */
   addPlugin(pluginImport: string, pluginName: string): void;
-  addImport(importName: string, importPath: string, isDefault?: boolean): ConfigBuilder;
-  useImport(configPath: string, importName: string): void;
 
+  /**
+   * addImport - Add a non-plugin import to the gasket file
+   * @param {string} importName - name of the import used as a value - `import fs...`
+   * @param {string} importPath - path of the import - `from 'fs'`
+   * @returns {ConfigBuilder} - instance for chaining
+   * @example
+   * Can be default or named import
+   * addImport('{ readFileSync }', 'fs')
+   * addImport('fs', 'fs')
+   *
+   * // gasket.js
+   * import { readFileSync } from 'fs';
+   * import fs from 'fs';
+   */
+  addImport(importName: string, importPath: string): ConfigBuilder<Config>;
+
+  /**
+   * addExpression - add programmatic expression to the gasket file
+   * @param {string} expression - expression to add after imports
+   * @returns {ConfigBuilder} - instance for chaining
+   * @example
+   *
+   * .addImport('fs', 'fs')
+   * .addExpression('const file = fs.readFileSync(\'./file.txt\')')
+   *
+   * // gasket.js
+   * import fs from 'fs';
+   * const file = fs.readFileSync('./file.txt');
+   */
+  addExpression(expression: string): ConfigBuilder<Config>;
+
+  /**
+   * injectValue - Inject a value into the gasket config object
+   * @param {string} configKey - collapsed object path to inject value into - `express.config.routes`
+   * @param {string} injectedValue - string used as a value
+   * @example
+   * .addImport('{ routes }', './routes')
+   * .injectValue('express.routes', 'routes');
+   *
+   * // gasket.js
+   * export default makeGasket({
+   *  express: {
+   *    routes: routes
+   *  }
+   * });
+   */
+  injectValue(configKey: string, injectedValue: string): void;
 }
 
 export interface PackageJsonBuilder extends ConfigBuilder<PackageJson> {
   /**
-   * Checks if a dependency has been already added
-   * @param  key - Dependency bucket
-   * @param  value - Dependency to search
-   * @returns True if the dependency exists on the bucket
+   * Checks if a property exists on the package.json fields.
+   * @param  key - Field to search
+   * @param  value - Value to search for
+   * @returns True if the property exists and matches the value
    */
-  has(key: keyof Dependencies, value: string): boolean;
+  has(key: keyof PackageJson, value: string): boolean;
 }
 
 export interface Files {
-  add(...args: string[]): void
+  add(...args: string[]): void;
 }
 
 export interface CreateContext {
@@ -107,12 +166,6 @@ export interface CreateContext {
    * load-preset if using localPresets. */
   rawPresets: Array<string>;
 
-  /** Raw plugin desc from flags, prompts, etc. Can include constraints. */
-  rawPlugins: Array<string>;
-
-  /** Short names of plugins */
-  plugins: Array<string>;
-
   /** Local packages that should be linked */
   pkgLinks: Array<string>;
 
@@ -131,6 +184,12 @@ export interface CreateContext {
   /** any generated files to show in report */
   generatedFiles: Set<string>;
 
+  /** Default empty array, populated by load-preset with actual imports */
+  presets: Array<Plugin>;
+
+  /** Default to object w/empty plugins array to be populated by `presetConfig` hook */
+  presetConfig: GasketConfigDefinition;
+
   // Added by `global-prompts`
 
   /** Description of app */
@@ -139,8 +198,8 @@ export interface CreateContext {
   /** Should a git repo be initialized and first commit */
   gitInit: boolean;
 
-  /** Name of the plugin for unit tests */
-  testPlugin: string;
+  /** Names of the plugins that add unit and integration tests */
+  testPlugins: Array<string>;
 
   /** Which package manager to use (Default: 'npm') */
   packageManager: string;
@@ -154,23 +213,6 @@ export interface CreateContext {
   /** Whether or not the user wants to override an extant directory */
   destOverride: boolean;
 
-  // Added by `load-preset`
-
-  /** Short name of presets */
-  presets: Array<string>;
-
-  /** Shallow load of presets with meta data */
-  presetInfos: Array<PresetInfo>;
-
-  // Added by `cli-version`
-
-  /** Version of current CLI used to issue `create` command */
-  cliVersion: string;
-
-  /** Version of CLI to install, either current or min compatible version
-   * required by preset(s) */
-  cliVersionRequired: string;
-
   // Added by `setup-pkg`
 
   /** package.json builder */
@@ -190,13 +232,23 @@ export interface CreateContext {
   files: Files;
 }
 
-declare module '@gasket/engine' {
+export interface ActionWrapperParams {
+  gasket: GasketEngine;
+  context: CreateContext;
+  spinner?: any;
+}
+
+declare module '@gasket/core' {
   export interface HookExecTypes {
+    presetPrompt(context: CreateContext): Promise<void>;
+    presetConfig(context: CreateContext): Promise<CreateContext['presetConfig']>;
     prompt(
       context: CreateContext,
       utils: {
-        prompt: (prompts: Array<Record<string, any>>) => Promise<Record<string, any>>,
-        addPlugins: (plugins: Array<string>) => Promise<void>
+        prompt: (
+          prompts: Array<Record<string, any>>
+        ) => Promise<Record<string, any>>;
+        addPlugins: (plugins: Array<string>) => Promise<void>;
       }
     ): MaybeAsync<CreateContext>;
 
@@ -205,7 +257,8 @@ declare module '@gasket/engine' {
     postCreate(
       context: CreateContext,
       utils: {
-        runScript: (script: string) => Promise<void>
-      }): MaybeAsync<void>;
+        runScript: (script: string) => Promise<void>;
+      }
+    ): MaybeAsync<void>;
   }
 }

package/lib/index.js

@@ -2,7 +2,8 @@
 import { Command } from 'commander';
 import { createRequire } from 'module';
 import { createCommand } from './commands/create.js';
-import { processCommand, logo, warnIfOutdated } from './utils/index.js';
+import { processCommand, logo } from './utils/index.js';
+import { warnIfOutdated } from '@gasket/utils';
 
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
@@ -19,7 +20,7 @@ const gasketBin = program
 
 async function main() {
   const { command, hidden, isDefault } = processCommand(createCommand);
-  // await warnIfOutdated(pkg.name, pkg.version);
+  await warnIfOutdated(pkg.name, pkg.version);
   gasketBin.addCommand(command, { hidden, isDefault });
 
   process.argv.splice(2, 0, 'create');

package/lib/scaffold/action-wrapper.js

@@ -14,14 +14,16 @@ export default function withSpinner(label, fn, { startSpinner = true } = {}) {
   /**
    * Decorated function
    *
-   * @param {CreateContext} context - Create context
+   * @param {ActionWrapperParams} params - ActionWrapperParams
+   * @param {GasketEngine} params.gasket - Gasket config
+   * @param {CreateContext} params.context - Create context
    * @returns {Promise} promise
    */
-  async function wrapper(gasket = {}, context) {
+  async function wrapper({ gasket = {}, context }) {
     const spinner = ora(label);
     if (startSpinner) spinner.start();
     try {
-      await fn(gasket, context, spinner);
+      await fn({ gasket, context, spinner });
       if (spinner.isSpinning) spinner.succeed();
     } catch (err) {
       spinner.fail();
@@ -32,4 +34,4 @@ export default function withSpinner(label, fn, { startSpinner = true } = {}) {
 
   wrapper.wrapped = fn;
   return wrapper;
-};
+}

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

@@ -1,4 +1,3 @@
-import { createEngine } from '../create-engine.js';
 import action from '../action-wrapper.js';
 import { ConfigBuilder } from '../config-builder.js';
 import { Files } from '../files.js';
@@ -7,11 +6,12 @@ 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 { dest, presets = [], plugins = [], warnings } = context;
+async function createHooks({ gasket, context }) {
+  const { plugins = [], warnings } = context;
 
   const files = new Files();
   const gasketConfig = ConfigBuilder.create({}, { orderBy: ['plugins'], warnings, plugins });

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

@@ -164,7 +164,7 @@ async function performGenerate(context, descriptors) {
  * @param {Spinner} spinner - Spinner
  * @returns {Promise} promise
  */
-async function generateFiles(gasket, context, spinner) {
+async function generateFiles({ context, spinner }) {
   const { files } = context;
 
   if (!files.globSets.length) {

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

@@ -1,9 +1,6 @@
 import inquirer from 'inquirer';
 import action from '../action-wrapper.js';
 
-import { pluginIdentifier, flattenPresets } from '@gasket/resolve';
-import { addPluginsToContext } from '../utils.js';
-
 /**
  * What is your app description?
  *
@@ -64,54 +61,54 @@ async function choosePackageManager(context, prompt) {
 }
 
 /**
- * Choose your unit test suite
+ * 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 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/plugin-mocha', jest: '@gasket/plugin-jest', cypress: '@gasket/plugin-cypress' };
-
-  if (!('testPlugin' in context)) {
-    // let testPlugin = Object.values(knownTestPlugins).find((p) => allPlugins.includes(p));
-    let testPlugin;
+async function chooseTestPlugins(context, prompt) {
+  const knownTestPlugins = {
+    unit: { mocha: '@gasket/plugin-mocha', jest: '@gasket/plugin-jest' },
+    integration: { cypress: '@gasket/plugin-cypress' }
+  };
 
-    if ('testSuite' in  context) {
-      testPlugin = knownTestPlugins[context.testSuite];
+  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 (!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/plugin-mocha' },
-            { name: 'jest', value: '@gasket/plugin-jest' },
-            { name: 'cypress', value: '@gasket/plugin-cypress' }
-          ]
-        }
-      ]));
+    if (testPlugins.length > 0) {
+      Object.assign(context, { testPlugins });
     }
+  }
+}
 
-    if (testPlugin && testPlugin !== 'none') {
-      // addPluginsToContext([testPlugin], context);
-      Object.assign(context, { testPlugin });
+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;
 }
 
 /**
@@ -141,7 +138,7 @@ async function allowExtantOverwriting(context, prompt) {
 export const questions = [
   chooseAppDescription,
   choosePackageManager,
-  chooseTestPlugin,
+  chooseTestPlugins,
   allowExtantOverwriting
 ];
 
@@ -151,7 +148,7 @@ export const questions = [
  * @param {CreateContext} context - Create context
  * @returns {Promise} promise
  */
-async function globalPrompts(gasket, context) {
+async function globalPrompts({ context }) {
   const prompt = context.prompts ? inquirer.prompt : () => ({});
   for (var fn of questions) {
     await fn(context, prompt);

package/lib/scaffold/actions/index.js

@@ -1,42 +1,33 @@
 import mkDir from './mkdir.js';
 import loadPreset from './load-preset.js';
-import cliVersion from './cli-version.js';
 import globalPrompts from './global-prompts.js';
 import setupPkg from './setup-pkg.js';
-import writePkg, { writePkgUpdate } from './write-pkg.js';
-import installModules, { installModulesUpdate } from './install-modules.js';
-import linkModules, { linkModulesUpdate } from './link-modules.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 loadPkgForDebug from './load-pkg-for-debug.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 applyPresetConfig from './apply-preset-config.js';
 import printReport from './print-report.js';
 
 export {
   mkDir,
   loadPreset,
-  cliVersion,
   globalPrompts,
   setupPkg,
   writePkg,
-  writePkgUpdate,
   installModules,
-  installModulesUpdate,
   linkModules,
-  linkModulesUpdate,
   writeGasketConfig,
-  loadPkgForDebug,
   presetPromptHooks,
   presetConfigHooks,
   promptHooks,
   createHooks,
   postCreateHooks,
   generateFiles,
-  applyPresetConfig,
   printReport
 };

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

@@ -6,13 +6,10 @@ import action from '../action-wrapper.js';
  * @param {CreateContext} context - Create context
  * @returns {Promise} promise
  */
-async function installModules(gasket, context) {
+async function installModules({ context }) {
   const { pkgManager } = context;
 
   await pkgManager.install();
 }
 
-
 export default action('Install node modules', installModules);
-
-export const installModulesUpdate = action('Update node modules', installModules);

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

@@ -7,7 +7,7 @@ import action from '../action-wrapper.js';
  * @param {Spinner} spinner - Spinner
  * @returns {Promise} promise
  */
-async function linkModules(gasket, context, spinner) {
+async function linkModules({ context, spinner }) {
   const { pkgLinks, pkgManager } = context;
 
   if (pkgLinks && pkgLinks.length) {
@@ -17,5 +17,3 @@ async function linkModules(gasket, context, spinner) {
 }
 
 export default action('Link node modules', linkModules, { startSpinner: false });
-
-export const linkModulesUpdate = action('Relink node modules', linkModules, { startSpinner: false });