create-gasket-app 7.0.0-next.3 → 7.0.0-next.30

package/lib/commands/create.js

@@ -1,34 +1,27 @@
-/* eslint-disable max-statements */
-import ora from 'ora';
+/* 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';
+import { rm } from 'fs/promises';
+import { makeGasket } from '@gasket/core';
+import { defaultPlugins } from '../config/default-plugins.js';
 import {
-  applyPresetConfig,
-  cliVersion,
   createHooks,
   generateFiles,
   globalPrompts,
   installModules,
   linkModules,
-  loadPkgForDebug,
   loadPreset,
   mkDir,
   postCreateHooks,
   printReport,
   presetPromptHooks,
+  presetConfigHooks,
   promptHooks,
   setupPkg,
   writeGasketConfig,
   writePkg
 } from '../scaffold/actions/index.js';
-import path from 'path';
-import os from 'os';
-import { mkdtemp, rm } from 'fs/promises';
-import { default as gasketUtils } from '@gasket/utils';
-import { makeGasket } from '@gasket/core';
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
 
 /**
  * Parses comma separated option input to array
@@ -57,13 +50,6 @@ const createCommand = {
       Or other (multiple) custom presets (e.g. --presets my-gasket-preset@1.0.0.beta-1,nextjs@^1.0.0)`,
       parse: commasToArray
     },
-    {
-      name: 'plugins',
-      description: `Additional plugin(s) to install. Can be set as
-      multiple flags (e.g. --plugins jest --plugins zkconfig@^1.0.0)
-      comma-separated values: --plugins=jest,zkconfig^1.0.0`,
-      parse: commasToArray
-    },
     {
       name: 'package-manager',
       description: `Selects which package manager you would like to use during
@@ -75,18 +61,6 @@ const createCommand = {
       description: 'Require module(s) before Gasket is initialized',
       parse: commasToArray
     },
-    {
-      name: 'no-bootstrap',
-      description: '(INTERNAL) If provided, skip the bootstrap phase',
-      type: 'boolean',
-      hidden: true
-    },
-    {
-      name: 'no-generate',
-      description: '(INTERNAL) If provided, skip the generate phase',
-      type: 'boolean',
-      hidden: true
-    },
     {
       name: 'npm-link',
       description: `(INTERNAL) Local packages to be linked. Can be set as
@@ -113,207 +87,14 @@ const createCommand = {
       conflicts: ['config']
     },
     {
-      name: 'prompts',
+      name: 'no-prompts',
       description: '(INTERNAL) Disable to skip the prompts',
-      default: true,
       type: 'boolean',
       hidden: true
     }
   ]
 };
 
-async function wait(ms = 50) {
-  return new Promise(resolve => {
-    console.log('waiting...')
-    setTimeout(resolve, ms);
-  });
-}
-
-function evaluatePreset(preset) {
-  const parts = preset.split('@').filter(Boolean);
-  if (parts.length > 1) {
-    return {
-      name: `@${parts[0]}`,
-      version: parts[1]
-    };
-  } else if (parts.length === 1) {
-    return {
-      name: `@${parts[0]}`,
-      version: null
-    };
-  }
-
-  return preset;
-}
-
-createCommand.action = async function run(appname, options, command) {
-  // temp
-  process.env.GASKET_DEBUG_NPM = 'true';
-  // temp
-  const context = makeCreateContext([appname], options);
-  const {
-    presets = [],
-    presetPath = [],
-  } = options;
-
-  const tmpDir = await mkdtemp(path.join(os.tmpdir(), `gasket-create-${context.appName}`));
-  const modPath = path.join(tmpDir, 'node_modules');
-  console.log(tmpDir);
-  await globalPrompts(context);
-
-  const pkgManager = new gasketUtils.PackageManager({ packageManager: context.packageManager, dest: tmpDir });
-  const pkgVerb = pkgManager.isYarn ? 'add' : 'install';
-
-  const remotePresets = await Promise.all(presets.map(async preset => {
-    await pkgManager.exec(pkgVerb, [preset]);
-    const pkgFile = require(path.join(modPath, preset, 'package.json'));
-    const presetMod = await import(pkgFile.name, { from: modPath });
-
-    const dependencies = Object.entries(pkgFile.dependencies || {})
-      .filter(([name]) => name.startsWith('@gasket'))
-      .map(([name, version]) => ({ name, version }));
-
-    const plugins = await Promise.all(dependencies.map(async ({ name }) => {
-      const mod = await import(name, { from: modPath });
-      return mod.default || mod;
-    }));
-
-    return {
-      pkgFile,
-      dependencies,
-      plugins: [
-        presetMod.default || presetMod,
-        ...plugins
-      ]
-    }
-  }));
-
-  const localPresets = await Promise.all(presetPath.map(async localPreset => {
-    await pkgManager.exec(pkgVerb, [localPreset]);
-    const pkgFile = require(path.join(localPreset, 'package.json'));
-    const presetMod = await import(pkgFile.name, { from: modPath });
-
-    const dependencies = Object.entries(pkgFile.dependencies || {})
-      .filter(([name]) => name.startsWith('@gasket'))
-      .map(([name, version]) => ({ name, version }));
-
-    const plugins = await Promise.all(dependencies.map(async ({ name }) => {
-      const mod = await import(name, { from: modPath });
-      return mod.default || mod;
-    }));
-
-    return {
-      module: presetMod.default || presetMod,
-      pkgFile,
-      dependencies,
-      plugins
-    };
-  }));
-
-
-  const configuredPresets = await Promise.all([
-    ...remotePresets,
-    ...localPresets
-  ]);
-
-  const presetPlugins = configuredPresets.reduce((acc, p) => {
-    return [
-      ...acc,
-      p.module
-    ];
-  }, []);
-
-  const presetGasket = makeGasket({
-    plugins: presetPlugins
-  });
-
-  console.log(presetGasket);
-
-  await presetPromptHooks(presetGasket, context);
-  console.log(context);
-  const presetConfig = await presetGasket.execWaterfall('presetConfig', context);
-
-  console.log(configuredPresets)
-  console.log(configuredPresets[0].dependencies)
-  console.log(configuredPresets[0].plugins)
-  console.log(presetConfig);
-
-  // Check preset plugins vs the plugins from the presetConfig
-
-
-
-  //   await globalPrompts(context);
-  // presetPrompt
-  // presetConfig
-
-  // const gasketPlugins = makeGasket({
-  //   // plugins
-  // })
-
-  // promptHooks
-
-
-  // applyPresetConfig(context);
-  // await globalPrompts(context);
-  // await mkDir(context);
-  // await setupPkg(context);
-  // await writePkg(context);
-  // await installModules(context);
-  // await linkModules(context);
-  // await promptHooks(gasketPlugins, context);
-  //   await createHooks(context);
-  //   await generateFiles(context);
-  //   await writeGasketConfig(context);
-  //   await writePkg.update(context);
-  //   await installModules.update(context);
-  //   await linkModules.update(context); // relink any that were messed up by re-install
-  //   await postCreateHooks(context);
-
-
-  // download preset to os temp dir
-  // import preset to CGA
-  // makeGasket with preset
-  // exec presetPrompt
-  // exec presetConfig
-  // makeGasket with presetConfig
-  // exec prompt
-  // exec create
-
-  // console.log('Deleting tmp dir...')
-  // await rm(tmpDir, { recursive: true });
-}
-
-/**
- * bootstrap - Bootstrap the application
- * @param {CreateContext} context - Create context
- */
-// async function bootstrapHandler(context) {
-//   await loadPreset(context);
-//   cliVersion(context);
-//   applyPresetConfig(context);
-//   await globalPrompts(context);
-//   await mkDir(context);
-//   await setupPkg(context);
-//   await writePkg(context);
-//   await installModules(context);
-//   await linkModules(context);
-// }
-
-/**
- * generate - Generate the application
- * @param {CreateContext} context - Create context
- */
-// async function generateHandler(context) {
-//   await promptHooks(context);
-//   await createHooks(context);
-//   await generateFiles(context);
-//   await writeGasketConfig(context);
-//   await writePkg.update(context);
-//   await installModules.update(context);
-//   await linkModules.update(context); // relink any that were messed up by re-install
-//   await postCreateHooks(context);
-// }
-
 /**
  * createCommand action
  * @param {string} appname Required cmd arg - name of the app to create
@@ -321,113 +102,47 @@ createCommand.action = async function run(appname, options, command) {
  * @param {Command} command - the command instance
  * @returns {Promise<void>} void
  */
-// createCommand.action = async function run(appname, options, command) {
-//   const argv = [appname];
-//   const { bootstrap = true, generate = true } = options;
+createCommand.action = async function run(appname, options, command) {
+  process.env.GASKET_ENV = 'create';
+  const context = makeCreateContext([appname], options);
+  const { rawPresets, localPresets } = context;
 
-//   let context;
-//   try {
-//     context = makeCreateContext(argv, options);
-//   } catch (error) {
-//     console.error(chalk.red(error) + '\n');
-//     command.help();
-//   }
+  try {
+    await globalPrompts({ context });
 
-//   try {
-//     if (bootstrap) {
-//       await bootstrapHandler(context);
-//     } else {
-//       ora('Bootstrap phase skipped.').warn();
-//       if (generate) {
-//         await loadPkgForDebug(context);
-//       }
-//     }
+    if (rawPresets.length || localPresets.length) {
+      await loadPreset({ context });
 
-//     if (generate) {
-//       await generateHandler(context);
-//     } else {
-//       ora('Generate phase skipped.').warn();
-//     }
+      const presetGasket = makeGasket({
+        plugins: context.presets
+      });
 
-//     printReport(context);
+      await presetPromptHooks({ gasket: presetGasket, context });
+      await presetConfigHooks({ gasket: presetGasket, context });
+    }
 
-//   } catch (err) {
-//     console.error(chalk.red('Exiting with errors.'));
-//     dumpErrorContext(context, err);
-//     throw err;
-//   }
-// };
+    const pluginGasket = makeGasket({
+      ...context.presetConfig,
+      plugins: context.presets.concat(context.presetConfig.plugins, defaultPlugins)
+    });
+
+    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 };
-
-
-
-  // fire global prompts to inform pkgmanager
-
-  // const tmpDir = await mkdtemp(path.join(os.tmpdir(), `gasket-create-${context.appName}`));
-  // console.log(tmpDir);
-
-
-
-  // new PackageManager https://github.com/godaddy/gasket/blob/v7/packages/gasket-utils/lib/package-manager.js#L75
-  // const remotePresets = context.rawPresets.map(async preset => {
-  //   const { name: presetName, version: presetVersion } = evaluatePreset(preset)
-
-  //   // await runShellCommand('npm', ['i', `${presetName}@${presetVersion}`], { cwd: tmpDir }, true);
-  //   const modPath = path.join(tmpDir, 'node_modules');
-  //   const pkgFile = require(path.join(modPath, presetName, 'package.json'));
-  //   const presetMod = await import(presetName, { from: modPath });
-
-  //   const dependencies = Object.entries(pkgFile.dependencies || {})
-  //     .filter(([name]) => name.startsWith('@gasket'))
-  //     .map(([name, version]) => ({ name, version }));
-
-  //   const plugins = await Promise.all(dependencies.map(async ({ name }) => {
-  //     const mod = await import(name, { from: modPath });
-  //     return mod.default || mod;
-  //   }));
-
-  //   console.log(plugins)
-  //   return {
-  //     // module: await import(preset, { from: modPath }),
-  //     pkgFile,
-  //     dependencies,
-  //     plugins: [
-  //       presetMod.default || presetMod,
-  //       ...plugins
-  //     ]
-  //   }
-  // });
-
-  // const localPresets = context.localPresets.map(async localPreset => {
-  //   await runShellCommand('npm', ['i', localPreset], { cwd: tmpDir }, true);
-
-  //   const modPath = path.join(tmpDir, 'node_modules');
-  //   const pkgFile = require(path.join(localPreset, 'package.json'));
-  //   const presetMod = await import(pkgFile.name, { from: modPath });
-
-
-  //   const dependencies = Object.entries(pkgFile.dependencies || {})
-  //     .filter(([name]) => name.startsWith('@gasket'))
-  //     .map(([name, version]) => ({ name, version }));
-
-  //   const plugins = await Promise.all(dependencies.map(async ({ name }) => {
-  //     const mod = await import(name, { from: modPath });
-  //     return mod.default || mod;
-  //   }));
-
-  //   return {
-  //     // module: await import(preset, { from: modPath }),
-  //     pkgFile,
-  //     dependencies,
-  //     plugins: [
-  //       presetMod.default || presetMod,
-  //       ...plugins
-  //     ]
-  //   }
-  // });
-
-  // const presets = await Promise.all([
-  //   ...remotePresets,
-  //   ...localPresets
-  // ]);

package/lib/config/default-plugins.js

@@ -1,7 +1,7 @@
-import pluginMetadata from '@gasket/plugin-metadata';
 import pluginGit from '@gasket/plugin-git';
+import pluginLogger from '@gasket/plugin-logger';
 
 export const defaultPlugins = [
-  pluginMetadata,
+  pluginLogger,
   pluginGit
 ];

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> {
   /**
@@ -62,20 +61,86 @@ export interface ConfigBuilder<Config> {
     value: Config[Key],
     options?: { force?: boolean }
   ): void;
+
+  /**
+   * 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 - 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 {
@@ -101,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>;
 
@@ -125,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 */
@@ -133,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;
@@ -148,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 */
@@ -184,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>;
 
@@ -199,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');