@corva/create-app 0.27.0-rc.0 → 0.28.0-2

package/lib/flows/steps/zip-cleanup.js

@@ -0,0 +1,17 @@
+const { promises: fs } = require('fs');
+const { resolve } = require('path');
+
+const debug = require('debug')('cca:flow:zip:cleanup');
+
+const CLEANUP_STEP = {
+  message: 'Removing temporary files...',
+  fn: async ({ itemsToRemove, dirName }) => {
+    for (const item of itemsToRemove) {
+      debug('Removing %s', item);
+
+      await fs.unlink(resolve(dirName, item));
+    }
+  },
+};
+
+module.exports = { CLEANUP_STEP };

package/lib/flows/steps/zip-create-archive.js

@@ -0,0 +1,15 @@
+const { createZipArchive } = require('../lib/create-zip-archive');
+const debug = require('debug')('cca:flow:zip:archive');
+
+const CREATE_ARCHIVE_STEP = {
+  message: 'Creating archive...',
+  fn: async ({ itemsToZip, zipFileName, dirName }) => {
+    debug(`Zipping %d items to %s`, itemsToZip.length, zipFileName);
+
+    const bytes = await createZipArchive(dirName, zipFileName, itemsToZip);
+
+    debug(`Created %s with %d items (%d bytes)`, zipFileName, itemsToZip.length, bytes);
+  },
+};
+
+module.exports = { CREATE_ARCHIVE_STEP };

package/lib/flows/steps/zip-file-list-resolve.js

@@ -0,0 +1,185 @@
+const { set } = require('lodash/fp');
+const { resolve } = require('path');
+const { promises: fs } = require('fs');
+const Glob = require('glob');
+const chalk = require('chalk');
+const isGlob = require('is-glob');
+const { promisify } = require('util');
+const { getIncreasedVersion } = require('../../scripts/utils/version');
+const { loadJson } = require('../lib/json');
+const { StepError } = require('../lib/step-error');
+
+const glob = promisify(Glob);
+const debug = require('debug')('cca:flow:zip:resolve');
+
+const uniqueValues = (array) => Array.from(new Set(array));
+
+const FILE_LIST_RESOLVE_STEP = {
+  message: 'Resolving files list...',
+  fn: async (context) => {
+    const { patterns, manifest, dirName } = context;
+    const files = await transformPatternsIntoFileNames(dirName, patterns);
+
+    if (manifest.isUi()) {
+      return resolveDataToZipUiApp(files, context);
+    }
+
+    if (manifest.isNode()) {
+      return resolveDataForZipNodeJsApp(files, context);
+    }
+
+    if (manifest.isPython()) {
+      return resolveDataForZipPythonApp(files, context);
+    }
+
+    throw new Error(`Unsupported runtime: ${manifest.runtime}`);
+  },
+};
+
+const transformPatternsIntoFileNames = async (dirName, patterns) => {
+  const filesFromPatterns = [];
+
+  for (const pattern of patterns) {
+    if (pattern.includes('node_modules')) {
+      debug('Invalid file pattern', pattern);
+
+      continue;
+    }
+
+    if (!isGlob(pattern, { strict: false })) {
+      filesFromPatterns.push(pattern);
+
+      continue;
+    }
+
+    const files = await glob(pattern, { cwd: dirName, ignore: '**/node_modules' });
+
+    filesFromPatterns.push(...files);
+  }
+
+  return filesFromPatterns;
+};
+
+const resolveDataToZipUiApp = async (itemsToZip = [], { options, pkg, dirName }) => {
+  const version = await getIncreasedVersion(pkg.version, options);
+  const zipFileName = `${pkg.name}-${version}.zip`;
+  const itemsToSave = [];
+  const shouldUpdateVersion = version !== pkg.version;
+
+  if (shouldUpdateVersion) {
+    pkg.version = version;
+
+    itemsToSave.push({
+      name: 'package.json',
+      content: pkg,
+      message: chalk(
+        `\n${chalk.yellow`NOTE`}: Version of your app was updated to ${version} (package.json), please don't lower it.`
+      ),
+    });
+  }
+
+  itemsToSave.push({
+    name: 'packageForSource.json',
+    content: set(
+      'scripts',
+      {
+        build: 'webpack --config=./config-overrides.js --mode production',
+      },
+      pkg
+    ),
+  });
+
+  const itemsToRemove = ['packageForSource.json'];
+
+  itemsToZip.push(
+    'manifest.json',
+    'config-overrides.js',
+    'tsconfig.json',
+    '.npmrc',
+    'yarn.lock',
+    { path: resolve(dirName, 'packageForSource.json'), name: 'package.json' },
+    'src'
+  );
+
+  return {
+    zipFileName,
+    itemsToZip,
+    itemsToSave,
+    itemsToRemove,
+  };
+};
+
+const resolveDataForZipNodeJsApp = async (itemsToZip = [], { options, pkg, dirName }) => {
+  const version = await getIncreasedVersion(pkg.version, options);
+  const zipFileName = `${pkg.name}-${version}.zip`;
+  const itemsToSave = [];
+  const shouldUpdateVersion = version !== pkg.version;
+
+  if (shouldUpdateVersion) {
+    pkg.version = version;
+
+    itemsToSave.push({
+      name: 'package.json',
+      content: pkg,
+      message: chalk(
+        `\n${chalk.yellow`NOTE`}: Version of your app was updated to ${version} (package.json), please don't lower it.`
+      ),
+    });
+  }
+
+  const packageDirContent = await fs.readdir(dirName);
+  const shouldPushDefaultSrc = !itemsToZip.length;
+
+  itemsToZip.push('config', 'manifest.json', 'package.json');
+
+  if (packageDirContent.includes('package-lock.json')) {
+    itemsToZip.push('package-lock.json');
+
+    if (shouldUpdateVersion) {
+      itemsToSave.push({
+        name: 'package-lock.json',
+        content: set('version', version, await loadJson(dirName, 'package-lock.json')),
+      });
+    }
+  } else if (packageDirContent.includes('yarn.lock')) {
+    itemsToZip.push('yarn.lock');
+  } else {
+    throw new StepError(`No lock file found in ${dirName}`);
+  }
+
+  if (packageDirContent.includes('tsconfig.json')) {
+    itemsToZip.push('tsconfig.json', 'tsconfig.build.json');
+
+    if (shouldPushDefaultSrc) {
+      itemsToZip.push('index.ts', ...(await glob('+(src|lib)/**/*.ts', { cwd: dirName })));
+    }
+  } else if (shouldPushDefaultSrc) {
+    itemsToZip.push('index.js', ...(await glob('+(src|lib)/**/*.js', { cwd: dirName })));
+  }
+
+  return {
+    zipFileName,
+    itemsToZip: uniqueValues(itemsToZip),
+    itemsToSave,
+    itemsToRemove: [],
+  };
+};
+
+const resolveDataForZipPythonApp = async (itemsToZip = [], { manifest, dirName }) => {
+  const zipFileName = `${manifest.manifest.application.name}.zip`;
+
+  if (!itemsToZip.length) {
+    itemsToZip.push(...(await glob('**/*.py', { cwd: dirName })));
+  }
+
+  itemsToZip.push('manifest.json', 'requirements.txt');
+
+  return {
+    zipFileName,
+    itemsToZip: uniqueValues(itemsToZip),
+    itemsToSave: [],
+    itemsToRemove: [],
+  };
+};
+
+module.exports = { FILE_LIST_RESOLVE_STEP };

package/lib/flows/steps/zip-prepare.js

@@ -0,0 +1,21 @@
+const { saveJson } = require('../lib/json');
+
+const debug = require('debug')('cca:flow:zip:prepare');
+
+const PREPARE_FILES_BEFORE_ZIP_STEP = {
+  message: 'Preparing...',
+  fn: async ({ itemsToSave, dirName }) => {
+    for (const item of itemsToSave) {
+      debug(`Updating %s`, item.name);
+      await saveJson(dirName, item.name, item.content);
+
+      if (item.message) {
+        process.stdout.write(item.message);
+      }
+    }
+  },
+};
+
+module.exports = {
+  PREPARE_FILES_BEFORE_ZIP_STEP,
+};

package/lib/flows/steps/zip.js

@@ -0,0 +1,15 @@
+const { CLEANUP_STEP } = require('./zip-cleanup');
+const { CREATE_ARCHIVE_STEP } = require('./zip-create-archive');
+const { FILE_LIST_RESOLVE_STEP } = require('./zip-file-list-resolve');
+const { PREPARE_FILES_BEFORE_ZIP_STEP } = require('./zip-prepare');
+
+const ZIP_STEPS = [
+  FILE_LIST_RESOLVE_STEP,
+  PREPARE_FILES_BEFORE_ZIP_STEP,
+  CREATE_ARCHIVE_STEP,
+  CLEANUP_STEP,
+];
+
+module.exports = {
+  ZIP_STEPS,
+};

package/lib/flows/zip-simple.js

@@ -0,0 +1,8 @@
+const { ZIP_STEPS } = require('./steps/zip');
+
+const ZIP_SIMPLE_FLOW = {
+  name: 'zip (simple)',
+  steps: ZIP_STEPS,
+};
+
+module.exports = { ZIP_SIMPLE_FLOW };

package/lib/flows/zip.js

@@ -0,0 +1,9 @@
+const { PREPARE_FLOW } = require('./prepare');
+const { ZIP_STEPS } = require('./steps/zip');
+
+const ZIP_FLOW = {
+  name: 'zip',
+  steps: [PREPARE_FLOW, ...ZIP_STEPS],
+};
+
+module.exports = { ZIP_FLOW };

package/{helpers → lib/helpers}/manifest.js

@@ -34,11 +34,11 @@ function fillManifest(answers) {
     settings: {
       ...defaultManifestProperties.settings,
       runtime,
-      ...defaultAppSettings({
+      app: defaultAppSettings({
         type: answers.appType,
         schedulerType: answers.schedulerType,
         cronString: answers.cronString,
-        depthMilestone: answers.depthMilestone
+        depthMilestone: answers.depthMilestone,
       }),
     },
   };
@@ -63,19 +63,17 @@ function defaultAppSettings({ type, schedulerType, cronString, depthMilestone })
     return {};
   }
 
-  const schedulerAppSettings =
-    schedulerType === manifestConstants.SCHEDULER_TYPE_DEPTH.value
-      ? manifestConstants.defaultDepthSchedulerSettings
-      : manifestConstants.defaultTimeSchedulerSettings;
+  if (schedulerType === manifestConstants.SCHEDULER_TYPE_DEPTH.value) {
+    return {
+      scheduler_type: schedulerType,
+      depth_milestone: depthMilestone || 1
+    }
+  }
 
   return {
-    app: {
-      ...schedulerAppSettings,
-      scheduler_type: schedulerType,
-      cron_string: cronString,
-      depth_milestone: depthMilestone
-    },
-  };
+    scheduler_type: schedulerType,
+    cron_string: cronString || '*/5 * * * *',
+  }
 }
 
 module.exports = {

package/{index.js → lib/index.js}

@@ -4,15 +4,18 @@
 
 const chalk = require('chalk');
 const figlet = require('figlet');
-const commander = require('commander');
+const { Command, CommanderError, Option } = require('commander');
 const fs = require('fs-extra');
 const inquirer = require('inquirer');
 const os = require('os');
 const path = require('path');
 const semver = require('semver');
 
-const uiScripts = require('./scripts/ui');
-const { ensureLatestVersion } = require('./scripts/utils/version');
+const {
+  ensureLatestVersion,
+  warnIfOutdated,
+  ensureBumpVersion,
+} = require('./scripts/utils/version');
 const utils = require('./helpers/utils.js');
 const manifestHelpers = require('./helpers/manifest.js');
 const versioning = require('./helpers/versioning.js');
@@ -20,10 +23,16 @@ const versioning = require('./helpers/versioning.js');
 const packageConstants = require('./constants/package.js');
 const manifestConstants = require('./constants/manifest.js');
 
-const packageJson = require('./package.json');
+const packageJson = require('../package.json');
 const { clear } = require('console');
 const spawn = require('cross-spawn');
 const { APP_RUNTIMES, TEMPLATE_TYPES, APP_TYPES } = require('./constants/cli');
+const { runFlow } = require('./flow');
+const { ERROR_ICON } = require('./constants/messages');
+const { StepError } = require('./flows/lib/step-error');
+const { RELEASE_FLOW } = require('./flows/release');
+const { ZIP_FLOW } = require('./flows/zip');
+const { bumpVersionOptionDeprecated, bumpVersionOption } = require('./bump-version.option');
 
 const YARN_EXECUTABLE = 'yarn';
 
@@ -78,26 +87,31 @@ function checkOptions(opts) {
   };
 }
 
+const printDeprecationNotice = (param) =>
+  console.warn(
+    chalk.bgYellowBright`DEPRECATED OPTION: ${param}` +
+      ` Use ${chalk.cyan(`create-corva-app ${param} .`)} instead`
+  );
+
 async function initialChecks() {
-  program = new commander.Command('corva-create-app')
-    .version(packageJson.version)
-    .argument('[project-directory]', 'project directory to work with')
-    .usage(`${chalk.green('<project-directory>')} [options]`)
-    .action((name) => {
-      projectName = name;
+  program = new Command()
+    .hook('preAction', async () => {
+      checkNodeVersion();
+
+      await warnIfOutdated();
     })
-    .option('-z, --zip <type>', 'zip app source')
-    .option('--bump-version [string]', 'bump version')
-    .option('--release', 'release app')
-    .addOption(
-      new commander.Option(`-p, --packageManager [string]`, 'package manager to use')
-        .default(YARN_EXECUTABLE)
-        .choices(['npm', YARN_EXECUTABLE])
-    );
+    .configureOutput({ writeErr: () => undefined })
+    .exitOverride();
+
+  const createCommand = program
+    .command('create', { isDefault: true })
+    .description('Create a new app')
+    .argument('[project-directory]', 'project directory to work with', process.cwd())
+    .usage(`${chalk.green('<project-directory>')} [options]`);
 
   manifestConstants.manifestOptions(projectName).forEach((value) => {
     const type = typeof value.default;
-    const option = new commander.Option(
+    const option = new Option(
       `${value.alias ? `-${value.alias}, ` : ''}--${value.name} [${
         (type !== 'undefined' && type) || 'string'
       }]`,
@@ -118,46 +132,145 @@ async function initialChecks() {
       option.argParser(Number);
     }
 
-    program.addOption(option);
+    if (type !== 'undefined') {
+      option.default(value.default);
+    }
+
+    createCommand.addOption(option);
   });
 
-  program.parse(process.argv);
+  createCommand
+    .version(packageJson.version)
+    .addOption(
+      new Option(
+        '-z, --zip [string]',
+        chalk.bgYellow`DEPRECATED` + ` Use ${chalk.cyan`zip`} command instead`
+      )
+    )
+    .addOption(
+      new Option(
+        '--release',
+        chalk.bgYellow`DEPRECATED` + ` Use ${chalk.cyan`release`} command instead`
+      )
+    )
+    .addOption(bumpVersionOptionDeprecated);
 
-  checkNodeVersion();
+  createCommand.action(async (dirName, options) => {
+    projectName = dirName;
+    packageManager = options.packageManager || packageManager;
+    useTypescript = options.useTypescript || useTypescript;
 
-  const opts = program.opts();
+    if (options.zip || options.release) {
+      options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
+    }
 
-  packageManager = opts.packageManager || packageManager;
-  useTypescript = opts.useTypescript || useTypescript;
+    if (options.zip) {
+      printDeprecationNotice('zip');
+
+      return runFlow(ZIP_FLOW, { dirName, patterns: [], options });
+    }
+
+    if (options.release) {
+      printDeprecationNotice('release');
+
+      return runFlow(RELEASE_FLOW, { dirName, patterns: [], options });
+    }
+
+    startingMessage();
+
+    // NOTE: Default action
+    await createApp(options);
+  });
+
+  program
+    .command('zip')
+    .description('Bundle app')
+    .argument('<project-directory>', 'Project directory to work with')
+    .argument('[patterns...]', 'Additional patterns to zip', [])
+    .addOption(bumpVersionOption)
+    .action(async (dirName, patterns, options) => {
+      options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
+
+      return runFlow(ZIP_FLOW, { dirName, patterns, options });
+    });
+
+  program
+    .command('release')
+    .description('Release app')
+    .argument('<project-directory>', 'Project directory to work with')
+    .argument('[patterns...]', 'Additional patterns to zip', [])
+    .addOption(bumpVersionOption)
+    .action(async (dirName, patterns, options) => {
+      options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
+
+      return runFlow(RELEASE_FLOW, { dirName, patterns, options });
+    });
 
-  if (opts.zip) {
-    if (opts.zip === APP_RUNTIMES.UI)
-      return uiScripts.zipAppSource({
-        bumpVersion: opts.bumpVersion,
-      });
-    process.exit(0);
+  try {
+    await program.parseAsync(process.argv);
+  } catch (e) {
+    handleError(e);
+
+    process.exit(1);
   }
-  if (opts.release) {
-    return uiScripts.releaseAppZip({ bumpVersion: opts.bumpVersion });
-    process.exit(0);
+}
+
+const handleError = (e) => {
+  if (e instanceof CommanderError) {
+    handleCommanderError(e);
+
+    return;
   }
 
-  startingMessage();
+  process.stdout.write(ERROR_ICON);
 
-  if (!projectName) {
-    console.error('Please specify the project directory:');
-    console.log(`  ${chalk.cyan(program.name())} ${chalk.green('<project-directory>')}`);
-    console.log();
-    console.log('For example:');
-    console.log(`  ${chalk.cyan(program.name())} ${chalk.green('my-react-app')}`);
-    console.log();
-    console.log(`Run ${chalk.cyan(`${program.name()} --help`)} to see all options.`);
-    process.exit(1);
+  if (!(e instanceof StepError)) {
+    console.error(chalk.red(e));
+
+    return;
   }
 
-  // NOTE: Default action
-  await createApp(opts);
-}
+  console.log(chalk.red(e.message));
+  e.cause && console.error(chalk.red(e.cause));
+};
+
+const handleCommanderError = (e) => {
+  switch (e.code) {
+    case 'commander.missingArgument': {
+      const match = /error:.*'(.*)'/.exec(e.message);
+
+      if (match && match[1] === 'project-directory') {
+        const commandName = program.args[0] || program._defaultCommandName;
+
+        console.error('Please specify the project directory:');
+        console.log(
+          `  ${chalk.cyan(program.name())} ${commandName} ${chalk.green('<project-directory>')}`
+        );
+        console.log();
+        console.log('For example:');
+        console.log(
+          `  ${chalk.cyan(program.name())} ${commandName} ${chalk.green('my-react-app')}`
+        );
+        console.log();
+        console.log(
+          `Run ${chalk.cyan(`${program.name()} help ${commandName}`)} to see all options.`
+        );
+      } else {
+        console.error('❌', e.message);
+      }
+
+      break;
+    }
+    case 'commander.help':
+    case 'commander.helpDisplayed': {
+      // ignore
+      break;
+    }
+    default: {
+      console.error('❌', e.message);
+    }
+  }
+};
 
 async function initPackage(manifest) {
   const appType = manifest.application.type;
@@ -201,7 +314,7 @@ async function createApp(opts) {
       console.log(`${key} : ${values[key]}`);
     });
 
-    const manifest = manifestHelpers.fillManifest(values);
+    const manifest = manifestHelpers.fillManifest(opts);
 
     await initPackage(manifest);
   } else {
@@ -224,7 +337,7 @@ function addTemplate(root, appType, runtime) {
   console.log(chalk.green('Copying app template...'));
   console.log();
 
-  const templateFolder = path.resolve(__dirname, 'template', appType, runtime);
+  const templateFolder = path.resolve(__dirname, '..', 'templates', appType, runtime);
 
   utils.copyFolderRecursiveSync(templateFolder, root, runtime);
 
@@ -260,7 +373,7 @@ function patchSchedulerForPython(root, appType, runtime, manifest) {
     return;
   }
 
-  const templateFolder = path.resolve(__dirname, 'template', appType, runtime);
+  const templateFolder = path.resolve(__dirname, '..', 'templates', appType, runtime);
   const originalType = 'ScheduledDataTimeEvent';
   const replacementType =
     schedulerType === manifestConstants.SCHEDULER_TYPE_DEPTH.value
@@ -291,7 +404,7 @@ function addPackageJSON(root, appName) {
 }
 
 function updatePackageJSON(root, description, appType, runtime) {
-  const templateFolder = path.resolve(__dirname, 'template', appType, runtime);
+  const templateFolder = path.resolve(__dirname, '..', 'templates', appType, runtime);
 
   let packageJson = JSON.parse(fs.readFileSync(path.join(templateFolder, 'package.json'), 'utf-8'));
 
@@ -331,7 +444,7 @@ function installJsApp(appPath, appType) {
       .toString('utf8')
       .split('\n')
       // NOTE: filter out warnings caused by @corva/ui peer dependencies
-      .filter(line => !line.includes('@corva/ui'))
+      .filter((line) => !line.includes('@corva/ui'))
       .join('\n');
     console.log(error);
   }