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

package/lib/commands/create.js

@@ -1,9 +1,9 @@
 /* eslint-disable max-statements */
-const ora = require('ora');
-const chalk = require('chalk');
-const makeCreateContext = require('../scaffold/create-context');
-const dumpErrorContext = require('../scaffold/dump-error-context');
-const {
+import ora from 'ora';
+import chalk from 'chalk';
+import { makeCreateContext } from '../scaffold/create-context.js';
+import { dumpErrorContext } from '../scaffold/dump-error-context.js';
+import {
   applyPresetConfig,
   cliVersion,
   createHooks,
@@ -16,11 +16,19 @@ const {
   mkDir,
   postCreateHooks,
   printReport,
+  presetPromptHooks,
   promptHooks,
   setupPkg,
   writeGasketConfig,
   writePkg
-} = require('../scaffold/actions');
+} 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
@@ -114,36 +122,197 @@ const createCommand = {
   ]
 };
 
+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);
-}
+// 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);
-}
+// 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
@@ -152,41 +321,113 @@ async function generateHandler(context) {
  * @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;
-
-  let context;
-  try {
-    context = makeCreateContext(argv, options);
-  } catch (error) {
-    console.error(chalk.red(error) + '\n');
-    command.help();
-  }
+// createCommand.action = async function run(appname, options, command) {
+//   const argv = [appname];
+//   const { bootstrap = true, generate = true } = options;
 
-  try {
-    if (bootstrap) {
-      await bootstrapHandler(context);
-    } else {
-      ora('Bootstrap phase skipped.').warn();
-      if (generate) {
-        await loadPkgForDebug(context);
-      }
-    }
+//   let context;
+//   try {
+//     context = makeCreateContext(argv, options);
+//   } catch (error) {
+//     console.error(chalk.red(error) + '\n');
+//     command.help();
+//   }
 
-    if (generate) {
-      await generateHandler(context);
-    } else {
-      ora('Generate phase skipped.').warn();
-    }
+//   try {
+//     if (bootstrap) {
+//       await bootstrapHandler(context);
+//     } else {
+//       ora('Bootstrap phase skipped.').warn();
+//       if (generate) {
+//         await loadPkgForDebug(context);
+//       }
+//     }
 
-    printReport(context);
+//     if (generate) {
+//       await generateHandler(context);
+//     } else {
+//       ora('Generate phase skipped.').warn();
+//     }
 
-  } catch (err) {
-    console.error(chalk.red('Exiting with errors.'));
-    dumpErrorContext(context, err);
-    throw err;
-  }
-};
+//     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
+  //     ]
+  //   }
+  // });
 
-module.exports = createCommand;
+  // const presets = await Promise.all([
+  //   ...remotePresets,
+  //   ...localPresets
+  // ]);

package/lib/config/default-plugins.js

@@ -1,7 +1,7 @@
-module.exports = [
-  require('@gasket/plugin-lifecycle'),
-  require('@gasket/plugin-metadata'),
-  require('@gasket/plugin-start'),
-  require('@gasket/plugin-git'),
-  require('@gasket/plugin-logger')
+import pluginMetadata from '@gasket/plugin-metadata';
+import pluginGit from '@gasket/plugin-git';
+
+export const defaultPlugins = [
+  pluginMetadata,
+  pluginGit
 ];

package/lib/config/utils.js

@@ -0,0 +1,59 @@
+import { default as diagnostics } from 'diagnostics';
+import { pluginIdentifier } from '@gasket/resolve';
+import { defaultPlugins } from './default-plugins.js';
+const debug = diagnostics('gasket:cli:config:utils');
+
+/**
+ * Returns specified env option if set or appropriate fallback
+ *
+ * @param {Object} options - CLI Option
+ * @param {string} commandId - Name of the command
+ * @param {function} warn - Warning logger
+ * @returns {string} environment
+ */
+export function getEnvironment(options, commandId, warn) {
+  if (options.env) {
+    debug('Environment was passed through command line options', options.env);
+    return options.env;
+  }
+
+  // special snowflake case to match up `local` env with command unless set
+  if (commandId === 'local') {
+    debug('Environment defaulting to `local` due to `local` command');
+    return 'local';
+  }
+
+  const { NODE_ENV } = process.env;
+  if (NODE_ENV) {
+    warn(`No env specified, falling back to NODE_ENV: "${ NODE_ENV }".`);
+    return NODE_ENV;
+  }
+
+  warn('No env specified, falling back to "development".');
+  return 'development';
+}
+
+/**
+ * Inject the default plugins into the loaded config
+ *
+ * @param {Object} gasketConfig - Gasket config
+ * @returns {Object} updated config
+ */
+export function addDefaultPlugins(gasketConfig) {
+  const pluginsConfig = gasketConfig.plugins || {};
+  const { add = [], remove = [] } = pluginsConfig;
+  const filteredNames = new Set(
+    add.concat(remove).map(p => {
+      const name = typeof p === 'string' ? p : p.name;
+      return pluginIdentifier(name).fullName;
+    })
+  );
+  const pluginsToAdd = defaultPlugins.filter(p => !filteredNames.has(pluginIdentifier(p.name).fullName));
+  return {
+    ...gasketConfig,
+    plugins: {
+      ...pluginsConfig,
+      add: (add).concat(pluginsToAdd)
+    }
+  };
+}

package/lib/index.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-require('./utils/setup');
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import { createCommand } from './commands/create.js';
+import { processCommand, logo, warnIfOutdated } from './utils/index.js';
+
+const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
-const { Command } = require('commander');
 const program = new Command();
-const CreateCommand = require('./commands/create');
-
-const { processCommand, logo, warnIfOutdated } = require('./utils');
 
 // Create Gasket CLI
 const gasketBin = program
@@ -17,8 +18,8 @@ const gasketBin = program
 
 
 async function main() {
-  const { command, hidden, isDefault } = processCommand(CreateCommand);
-  await warnIfOutdated(pkg.name, pkg.version);
+  const { command, hidden, isDefault } = processCommand(createCommand);
+  // await warnIfOutdated(pkg.name, pkg.version);
   gasketBin.addCommand(command, { hidden, isDefault });
 
   process.argv.splice(2, 0, 'create');

package/lib/scaffold/action-wrapper.js

@@ -1,4 +1,4 @@
-const ora = require('ora');
+import ora from 'ora';
 
 /**
  * Decorate a create action with spinner.
@@ -10,19 +10,18 @@ const ora = require('ora');
  * @param {Boolean} startSpinner - Should the spinner start
  * @returns {Function} decorated action
  */
-module.exports = function withSpinner(label, fn, { startSpinner = true } = {}) {
-
+export default function withSpinner(label, fn, { startSpinner = true } = {}) {
   /**
    * Decorated function
    *
    * @param {CreateContext} context - Create context
    * @returns {Promise} promise
    */
-  async function wrapper(context) {
+  async function wrapper(gasket = {}, context) {
     const spinner = ora(label);
     if (startSpinner) spinner.start();
     try {
-      await fn(context, spinner);
+      await fn(gasket, context, spinner);
       if (spinner.isSpinning) spinner.succeed();
     } catch (err) {
       spinner.fail();

package/lib/scaffold/actions/apply-preset-config.js

@@ -1,5 +1,5 @@
-const { flattenPresets } = require('@gasket/resolve');
-const action = require('../action-wrapper');
+import { flattenPresets } from '@gasket/resolve';
+import action from '../action-wrapper.js';
 
 /**
  * Extracts predefined createContext from presets and applies to context.
@@ -26,4 +26,4 @@ function applyPresetConfig(context) {
   Object.assign(context, presetContext);
 }
 
-module.exports = action('Apply preset context', applyPresetConfig, { startSpinner: false });
+export default action('Apply preset context', applyPresetConfig, { startSpinner: false });

package/lib/scaffold/actions/cli-version.js

@@ -1,7 +1,11 @@
-const semver = require('semver');
-const { flattenPresets } = require('@gasket/resolve');
-const action = require('../action-wrapper');
-const pkgVersion = require('../../../package.json').version;
+import semver from 'semver';
+import { flattenPresets } from '@gasket/resolve';
+import action from '../action-wrapper.js';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const pkg = require('../../../package.json');
+
+const pkgVersion = pkg.version;
 const pkgVersionCompatible = `^${pkgVersion}`;
 
 /**
@@ -81,4 +85,4 @@ function resolveCliVersion(context, spinner) {
   });
 }
 
-module.exports = action('Resolve CLI versions', resolveCliVersion, { startSpinner: false });
+export default action('Resolve CLI versions', resolveCliVersion, { startSpinner: false });

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

@@ -1,7 +1,7 @@
-const createEngine = require('../create-engine');
-const action = require('../action-wrapper');
-const ConfigBuilder = require('../config-builder');
-const Files = require('../files');
+import { createEngine } from '../create-engine.js';
+import action from '../action-wrapper.js';
+import { ConfigBuilder } from '../config-builder.js';
+import { Files } from '../files.js';
 
 /**
  * Executes the `create` hook for all registered plugins.
@@ -17,10 +17,10 @@ async function createHooks(context) {
   const gasketConfig = ConfigBuilder.create({}, { orderBy: ['plugins'], warnings });
   Object.assign(context, { files, gasketConfig });
 
-  const gasket = await createEngine({ dest, presets, plugins });
+  const gasket = await createEngine(plugins);
   await gasket.execApply('create', async function applyCreate(plugin, handler) {
     await handler(context.runWith(plugin));
   });
 }
 
-module.exports = action('Execute create hooks', createHooks);
+export default action('Execute create hooks', createHooks);

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

@@ -1,14 +1,16 @@
-/* eslint-disable max-statements */
-const debug = require('diagnostics')('gasket:create-gasket-app:generate-files');
-const fs = require('fs').promises;
-const { promisify } = require('util');
-const Handlebars = require('handlebars');
-const path = require('path');
-const mkdirp = require('mkdirp');
-const { dim } = require('chalk');
-const action = require('../action-wrapper');
-
-const glob = promisify(require('glob'));
+import { default as diagnostics } from 'diagnostics';
+const debug = diagnostics('gasket:cli:generate-files');
+import fs from 'fs/promises';
+import { promisify } from 'util';
+import Handlebars from 'handlebars';
+import path from 'path';
+import mkdirp from 'mkdirp';
+import chalk from 'chalk';
+const { dim } = chalk;
+import action from '../action-wrapper.js';
+import * as syncGlob from 'glob';
+const glob = promisify(syncGlob.default);
+
 const flatten = (acc, values) => (acc || []).concat(values);
 const reSep = /[/\\]+/;
 const joinSep = pthArr => pthArr.join(path.sep);
@@ -177,7 +179,7 @@ async function generateFiles(context, spinner) {
   if (hasError) spinner.fail();
 }
 
-module.exports = action('Generate app contents', generateFiles);
+export default action('Generate app contents', generateFiles);
 // exported for unit testing
-module.exports._getDescriptors = getDescriptors;
-module.exports._assembleDescriptors = assembleDescriptors;
+export const _getDescriptors = getDescriptors;
+export const _assembleDescriptors = assembleDescriptors;

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

@@ -1,7 +1,8 @@
-const inquirer = require('inquirer');
-const { pluginIdentifier, flattenPresets } = require('@gasket/resolve');
-const action = require('../action-wrapper');
-const { addPluginsToContext } = require('../utils');
+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?
@@ -136,7 +137,7 @@ async function allowExtantOverwriting(context, prompt) {
   }
 }
 
-const questions = [
+export const questions = [
   chooseAppDescription,
   choosePackageManager,
   chooseTestPlugin,
@@ -156,6 +157,4 @@ async function globalPrompts(context) {
   }
 }
 
-module.exports = action('Global prompts', globalPrompts, { startSpinner: false });
-
-module.exports.questions = questions;
+export default action('Global prompts', globalPrompts, { startSpinner: false });