@corva/create-app 0.0.0-73c49372

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

@@ -0,0 +1,260 @@
+import chalk from 'chalk';
+import Glob from 'glob';
+import isGlob from 'is-glob';
+import _ from 'lodash/fp.js';
+import { promises as fs } from 'node:fs';
+import { resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { getIncreasedVersion } from '../../helpers/cli-version.js';
+import { generateRandomString } from '../../helpers/utils.js';
+import { loadJson } from '../lib/json.js';
+import { StepError } from '../lib/step-error.js';
+
+const glob = promisify(Glob);
+
+import debugFn from 'debug';
+
+const debug = debugFn('cca:flow:zip:resolve');
+
+const uniqueValues = (array) => Array.from(new Set(array));
+
+export const FILE_LIST_RESOLVE_STEP = {
+  message: 'Resolving files list...',
+  fn: async (context) => {
+    const { patterns, manifest, dirName, options } = context;
+    const files = await transformPatternsIntoFileNames(dirName, patterns, options.ignoredFiles);
+
+    if (manifest.isUi()) {
+      return resolveDataToZipUiApp(files, context);
+    }
+
+    if (manifest.isNode()) {
+      return resolveDataForZipNodeJsApp(files, context);
+    }
+
+    if (manifest.isPython()) {
+      return resolveDataForZipPythonApp(files, context);
+    }
+
+    throw new StepError(`Unsupported runtime: ${manifest.runtime}`);
+  },
+};
+
+const transformPatternsIntoFileNames = async (dirName, patterns, ignoredFiles = []) => {
+  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', ...ignoredFiles],
+      nodir: true,
+    });
+
+    filesFromPatterns.push(...files);
+  }
+
+  return filesFromPatterns;
+};
+
+/**
+ *
+ * @param {string[]} itemsToZip
+ * @param {object} param1
+ * @param {import('../lib/manifest').Manifest} param1.manifest
+ * @returns
+ */
+const resolveDataToZipUiApp = async (itemsToZip = [], { options, pkg, dirName, manifest, appKey }) => {
+  const version = await getIncreasedVersion(pkg.version, options);
+  const randomSuffix = generateRandomString(); // Random suffix is needed to not cause a conflict when we call 2 parallel commands at the same time.
+  const zipFileName = `${manifest.unix_name}-${version}-${randomSuffix}.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 tmpPackageForSourceName = `packageForSource_${randomSuffix}.json`;
+
+  itemsToSave.push({
+    name: tmpPackageForSourceName,
+    content: _.set(
+      'scripts',
+      {
+        build: 'webpack --config=./config-overrides.js --mode production',
+      },
+      pkg,
+    ),
+  });
+
+  const itemsToRemove = [tmpPackageForSourceName];
+
+  itemsToZip.push(
+    'manifest.json',
+    'config-overrides.js',
+    'tsconfig.json',
+    '.npmrc',
+    '.nvmrc',
+    'yarn.lock',
+    {
+      path: resolve(dirName, tmpPackageForSourceName),
+      name: 'package.json',
+    },
+    ...(await transformPatternsIntoFileNames(dirName, ['src/**/*'], options.ignoredFiles)),
+  );
+
+  if (options.appKey) {
+    /**
+     * Both manifest.json appKey in zip and the provided
+     * appKey param should match. That's why we set it for cases when appKey option
+     * is specified to override the one from manifest.json
+     */
+
+    const tmpManifestForSourceName = `manifestForSource_${randomSuffix}.json`;
+
+    itemsToSave.push({
+      name: tmpManifestForSourceName,
+      content: _.set('application.key', appKey, manifest.manifest),
+    });
+
+    itemsToRemove.push(tmpManifestForSourceName);
+
+    itemsToZip.push({
+      path: resolve(dirName, tmpManifestForSourceName),
+      name: 'manifest.json',
+    });
+  }
+
+  return {
+    zipFileName,
+    itemsToZip,
+    itemsToSave,
+    itemsToRemove,
+  };
+};
+
+/**
+ *
+ * @param {string[]} itemsToZip
+ * @param {object} param1
+ * @param {import('../lib/manifest').Manifest} param1.manifest
+ * @returns
+ */
+const resolveDataForZipNodeJsApp = async (itemsToZip = [], { options, pkg, dirName, manifest }) => {
+  const version = await getIncreasedVersion(pkg.version, options);
+  const zipFileName = `${manifest.unix_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', '.nvmrc', '.npmrc', '.eslintrc.js');
+
+  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}`);
+  }
+
+  const defaultSrcWithoutExtensions = '+(__tests__|src|lib)/**/*.';
+
+  if (packageDirContent.includes('tsconfig.json')) {
+    itemsToZip.push('tsconfig.json', 'tsconfig.build.json');
+
+    if (shouldPushDefaultSrc) {
+      itemsToZip.push(
+        'index.ts',
+        ...(await glob(`${defaultSrcWithoutExtensions}ts`, {
+          cwd: dirName,
+          ignore: options.ignoredFiles,
+        })),
+      );
+    }
+  } else if (shouldPushDefaultSrc) {
+    itemsToZip.push(
+      'index.js',
+      ...(await glob(`${defaultSrcWithoutExtensions}js`, {
+        cwd: dirName,
+        ignore: options.ignoredFiles,
+      })),
+    );
+  }
+
+  return {
+    zipFileName,
+    itemsToZip: uniqueValues(itemsToZip),
+    itemsToSave,
+    itemsToRemove: [],
+  };
+};
+
+/**
+ *
+ * @param {string[]} itemsToZip
+ * @param {object} param1
+ * @param {import('../lib/manifest').Manifest} param1.manifest
+ * @returns
+ */
+const resolveDataForZipPythonApp = async (itemsToZip = [], { manifest, dirName, options }) => {
+  const zipFileName = `${manifest.unix_name}.zip`;
+
+  if (!itemsToZip.length) {
+    itemsToZip.push(
+      ...(await glob('**/*.py', {
+        cwd: dirName,
+        ignore: [...(options.ignoredFiles || []), 'venv/**/*'],
+      })),
+    );
+  }
+
+  itemsToZip.push('manifest.json', 'requirements.txt');
+
+  return {
+    zipFileName,
+    itemsToZip: uniqueValues(itemsToZip),
+    itemsToSave: [],
+    itemsToRemove: [],
+  };
+};

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

@@ -0,0 +1,20 @@
+import { logger } from '../../helpers/logger.js';
+import { saveJson } from '../lib/json.js';
+
+import debugFn from 'debug';
+
+const debug = debugFn('cca:flow:zip:prepare');
+
+export 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) {
+        logger.write(item.message);
+      }
+    }
+  },
+};

package/lib/flows/steps/zip.js

@@ -0,0 +1,6 @@
+import { CLEANUP_STEP } from './zip-cleanup.js';
+import { CREATE_ARCHIVE_STEP } from './zip-create-archive.js';
+import { FILE_LIST_RESOLVE_STEP } from './zip-file-list-resolve.js';
+import { PREPARE_FILES_BEFORE_ZIP_STEP } from './zip-prepare.js';
+
+export const ZIP_STEPS = [FILE_LIST_RESOLVE_STEP, PREPARE_FILES_BEFORE_ZIP_STEP, CREATE_ARCHIVE_STEP, CLEANUP_STEP];

package/lib/flows/zip-simple.js

@@ -0,0 +1,6 @@
+import { ZIP_STEPS } from './steps/zip.js';
+
+export const ZIP_SIMPLE_FLOW = {
+  name: 'zip (simple)',
+  steps: ZIP_STEPS,
+};

package/lib/flows/zip.js

@@ -0,0 +1,7 @@
+import { PREPARE_FLOW } from './prepare.js';
+import { ZIP_STEPS } from './steps/zip.js';
+
+export const ZIP_FLOW = {
+  name: 'zip',
+  steps: [PREPARE_FLOW, ...ZIP_STEPS],
+};

package/lib/helpers/cli-version.js

@@ -0,0 +1,114 @@
+import NpmApi from 'npm-api';
+import chalk from 'chalk';
+import semver from 'semver';
+import inquirer from 'inquirer';
+import { join } from 'path';
+import * as url from 'url';
+
+import { logger } from './logger.js';
+import fs from 'fs-extra';
+
+const npm = new NpmApi();
+
+const error = chalk.bold.red;
+const warning = chalk.hex('#FFA500'); // Orange
+const code = chalk.cyan;
+const asterisks = '****************************************************************';
+
+const getCurrentVersion = async () =>
+  (await fs.readJSON(join(url.fileURLToPath(new URL('.', import.meta.url)), '../../package.json'))).version;
+const getLatestVersion = async () => npm.repo('@corva/create-app').prop('version');
+
+// NOTE: Stop process and show error if version is outdated
+export async function ensureLatestVersion() {
+  const currentVersion = await getCurrentVersion();
+  const latestVersion = await getLatestVersion();
+
+  const isCurrentVersionOutdated = semver.gt(latestVersion, currentVersion);
+
+  if (isCurrentVersionOutdated) {
+    console.log(error(asterisks));
+    console.log(error`
+      Your version of the @corva/create-app is outdated.
+      There is a new version available ({green.bold ${latestVersion}}).
+      Please update the @corva/create-app with the following command:
+
+          ${code('npm i -g @corva/create-app@latest')}
+
+    `);
+    console.log(error(asterisks));
+    process.exit(0);
+  }
+}
+
+// NOTE: Show user-friendly warning if version is outdated
+export async function warnIfOutdated() {
+  logger.write('Checking for updates...\n');
+
+  const currentVersion = await getCurrentVersion();
+  const latestVersion = await getLatestVersion();
+
+  const isCurrentVersionOutdated = semver.gt(latestVersion, currentVersion);
+
+  if (isCurrentVersionOutdated) {
+    console.log(warning(asterisks));
+    console.log(warning`
+      There is a new version available ({green.bold ${latestVersion}}).
+      You can update the CLI version with the following command:
+
+          ${code`npm i -g @corva/create-app@latest`}
+
+    `);
+    console.log(warning(asterisks));
+  } else {
+    logger.write('  ✅  \n');
+  }
+}
+
+const PROMPT_MESSAGE = `Bumping package version:
+${chalk.bold` Please select one of the options below:`}
+  `;
+
+export const ensureBumpVersion = async (bumpVersion) => {
+  if (bumpVersion) {
+    return bumpVersion;
+  }
+
+  const { option, custom } = await inquirer.prompt([
+    {
+      message: PROMPT_MESSAGE,
+      name: 'option',
+      type: 'list',
+      choices: [
+        { value: 'major', name: 'major (x+1.y.z)' },
+        { value: 'minor', name: 'minor (x.y+1.z)' },
+        { value: 'patch', name: 'patch (x.y.z+1)' },
+        new inquirer.Separator(),
+        { value: 'custom', name: 'Enter a custom version' },
+        { value: 'skip', name: 'Skip version bump' },
+      ],
+      default: 'patch',
+    },
+    {
+      message: 'Enter custom version',
+      name: 'custom',
+      when: (answers) => answers.option === 'custom',
+      type: 'input',
+      validate: (input) => (semver.valid(input) ? true : 'Invalid semver version'),
+    },
+  ]);
+
+  return option === 'custom' ? custom : option;
+};
+
+export async function getIncreasedVersion(version, { bumpVersion: releaseTypeOrNewVersion }) {
+  if (releaseTypeOrNewVersion === 'skip') {
+    return version;
+  }
+
+  if (semver.valid(releaseTypeOrNewVersion)) {
+    return releaseTypeOrNewVersion;
+  }
+
+  return semver.inc(version, releaseTypeOrNewVersion);
+}

package/lib/helpers/commands.js

@@ -0,0 +1,13 @@
+import { resolve } from 'node:path';
+
+export const silencer =
+  (handler) =>
+  async (...args) => {
+    const result = await handler(...args);
+
+    if (args[args.length - 2].silent && result) {
+      console.log(result);
+    }
+  };
+
+export const getRealWorkingDir = (relativePath, options) => resolve(options.originalCwd, relativePath);

package/lib/helpers/logger.js

@@ -0,0 +1,35 @@
+export class Logger {
+  constructor() {
+    this.isSilent = process.argv.includes('--silent');
+  }
+
+  write(str) {
+    if (this.isSilent) {
+      return;
+    }
+
+    if (str === undefined) {
+      process.stdout.write();
+
+      return;
+    }
+
+    process.stdout.write(str);
+  }
+
+  log(str) {
+    if (this.isSilent) {
+      return;
+    }
+
+    if (str === undefined) {
+      console.log();
+
+      return;
+    }
+
+    console.log(str);
+  }
+}
+
+export const logger = new Logger();

package/lib/helpers/manifest.js

@@ -0,0 +1,74 @@
+import { APP_RUNTIMES, APP_TYPES, TEMPLATE_TYPES } from '../constants/cli.js';
+import * as manifestConstants from '../constants/manifest.js';
+
+export function fillManifest(answers) {
+  const runtime = answers.runtime || APP_RUNTIMES.UI;
+
+  const defaultManifestProperties = _defaultManifestProperties({
+    type: answers.appType,
+    // fallback to UI
+    runtime,
+  });
+
+  const manifest = {
+    ...manifestConstants.defaultManifest,
+    ...defaultManifestProperties,
+    developer: {
+      ...manifestConstants.defaultManifest.developer,
+      ...defaultManifestProperties.developer,
+      name: answers.developerName,
+      identifier: answers.developerIdentifier,
+    },
+    application: {
+      ...manifestConstants.defaultManifest.application,
+      ...defaultManifestProperties.application,
+      key: answers.appKey,
+      name: answers.appName,
+      type: answers.appType,
+      description: answers.description,
+      summary: answers.summary,
+      category: answers.category,
+      website: answers.website,
+      segments: [answers.segments],
+    },
+    settings: {
+      ...defaultManifestProperties.settings,
+      runtime,
+      app: defaultAppSettings(answers),
+    },
+  };
+
+  return manifest;
+}
+
+function _defaultManifestProperties({ type, runtime }) {
+  if (type === APP_TYPES.UI) {
+    return manifestConstants.defaultUIAppManifest;
+  }
+
+  if (runtime.startsWith(TEMPLATE_TYPES.PYTHON)) {
+    return manifestConstants.defaultDataAppPythonManifest;
+  }
+
+  return manifestConstants.defaultDataAppNodeManifest;
+}
+
+function defaultAppSettings({ appType, schedulerType, cronString, depthMilestone, logType }) {
+  if (!schedulerType || appType !== APP_TYPES.SCHEDULER) {
+    return {
+      log_type: logType,
+    };
+  }
+
+  if (schedulerType === manifestConstants.SCHEDULER_TYPE_DEPTH.value) {
+    return {
+      scheduler_type: schedulerType,
+      depth_milestone: depthMilestone || 1,
+    };
+  }
+
+  return {
+    scheduler_type: schedulerType,
+    cron_string: cronString || '*/5 * * * *',
+  };
+}

package/lib/helpers/resolve-app-runtime.js

@@ -0,0 +1,128 @@
+import debugFn from 'debug';
+import { APP_TYPES } from '../constants/cli.js';
+
+const debug = debugFn('cca:resolve-app-runtime');
+
+import spawn from 'cross-spawn';
+import { promises as fs } from 'fs';
+import os from 'os';
+import semver from 'semver';
+
+/**
+ *
+ * @param {string} command
+ * @param {string} version
+ * @returns {Promise<boolean>}
+ */
+const checkCliVersion = async (command, version) =>
+  new Promise((resolve) => {
+    const child = spawn(command, ['--version']);
+
+    let data = '';
+
+    child.stderr.on('data', (buffer) => {
+      data += buffer;
+    });
+
+    child.stdout.on('data', (buffer) => {
+      data += buffer;
+    });
+
+    child.once('close', (code) => {
+      if (code !== 0) {
+        debug(`Command ${command} exited with code ${code}`);
+        debug('Output:', data.toString());
+
+        return resolve(false);
+      }
+
+      debug(`%s version output: %s`, command, data.toString());
+
+      resolve(semver.satisfies(semver.coerce(data.toString('utf-8')), version));
+    });
+  });
+
+const checkNodeVersion = (version) => async () => {
+  try {
+    await fs.access(`${os.homedir()}/.nvm/nvm.sh`);
+
+    debug('nvm is installed');
+
+    return true;
+  } catch (e) {
+    debug(e);
+    debug('nvm is not installed, checking node version');
+
+    return checkCliVersion('node', version);
+  }
+};
+
+export const IS_WINDOWS = process.platform === 'win32';
+
+const semverVersionsMapping = {
+  node: {
+    16: '16.19.0',
+    18: '18.13.0',
+  },
+  python: {
+    '3.8': '3.8.16',
+    '3.9': '3.9.16',
+    '3.10': '3.10.9',
+    '3.11': '3.11.1',
+  },
+};
+
+/**
+ * @typedef {Object} Runtime
+ * @property {string} language
+ * @property {boolean} isRuntimeAvailable
+ * @property {string} packageManager
+ * @property {string} version
+ * @property {string} semver
+ */
+export const resolveAppRuntime = (opts) => {
+  if (opts.appType === APP_TYPES.UI) {
+    const version = '18';
+
+    return {
+      language: opts.useTypescript ? 'typescript' : 'javascript',
+      isRuntimeAvailable: checkNodeVersion(version),
+      packageManager: opts.packageManager,
+      version,
+      semver: semverVersionsMapping.node[version],
+    };
+  }
+
+  if (opts.runtime.startsWith('node')) {
+    const version = /nodejs(\d{2})\.x/.exec(opts.runtime)[1];
+
+    return {
+      language: opts.useTypescript ? 'typescript' : 'javascript',
+      isRuntimeAvailable: checkNodeVersion(version),
+      packageManager: opts.packageManager,
+      version,
+      semver: semverVersionsMapping.node[version],
+    };
+  }
+
+  const version = /python(\d\.\d+)/.exec(opts.runtime)[1];
+
+  return {
+    language: 'python',
+    isRuntimeAvailable: async () => {
+      if (!IS_WINDOWS) {
+        return checkCliVersion(`python3`, version);
+      }
+
+      return (
+        (await checkCliVersion(`py -${version}`, version)) ||
+        (await checkCliVersion('python', version)) ||
+        (await checkCliVersion('python3', version))
+      );
+    },
+
+    packageManager: 'pip',
+    version,
+    semver: semverVersionsMapping.python[version],
+  };
+};