@corva/create-app 0.0.0-2576df8

package/lib/commands/create.js

@@ -0,0 +1,463 @@
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { clear } from 'node:console';
+import os from 'node:os';
+import { existsSync } from 'node:fs';
+
+import { Command, Option } from 'commander';
+import spawn from 'cross-spawn';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import figlet from 'figlet';
+import _ from 'lodash/fp.js';
+import inquirer from 'inquirer';
+
+import { originalCwdOption } from '../options/original-cwd.js';
+import { ensureBumpVersion, ensureLatestVersion } from '../helpers/cli-version.js';
+import { logger } from '../helpers/logger.js';
+import { IS_WINDOWS, resolveAppRuntime } from '../helpers/resolve-app-runtime.js';
+import { tryGitCommit, tryGitInit } from '../helpers/versioning.js';
+import { addUiAppFile, copyFolderRecursiveSync, getExcludedFiles, putVariablesInEnvFile } from '../helpers/utils.js';
+import { getDefaultsForPackageJson } from '../constants/package.js';
+import { getRealWorkingDir } from '../helpers/commands.js';
+import { Manifest } from '../flows/lib/manifest.js';
+import { fillManifest } from '../helpers/manifest.js';
+import { getManifestMandatoryKeys, manifestOptions } from '../constants/manifest.js';
+import { StepError } from '../flows/lib/step-error.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const WRITE_TO_JSON_OPTS = {
+  spaces: 2,
+  EOL: os.EOL,
+};
+
+export const createCommand = new Command('create')
+  .description('Create a new app')
+  .argument('[project-directory]', 'project directory to work with', process.argv[process.argv.length - 1])
+  .addOption(originalCwdOption);
+
+manifestOptions().forEach((value) => {
+  const type = value.commaSeparated ? 'string' : typeof value.default;
+  const cliType = type === 'undefined' ? (value.choices ? ' [string]' : '') : ` [${type}]`;
+  const alias = value.alias ? `-${value.alias}, ` : '';
+  const optionString = `${alias}--${value.name}${cliType}`;
+
+  const option = new Option(optionString, value.message);
+
+  if (value.choices) {
+    if (typeof value.choices === 'function') {
+      option.choices(value.choices());
+    } else {
+      option.choices(value.choices.map((choice) => `${typeof choice === 'object' ? choice.value : choice}`));
+    }
+  }
+
+  if (type === 'number') {
+    option.argParser(Number);
+  } else if (value.commaSeparated) {
+    option.argParser((str) => str.split(',').map((s) => s.trim()));
+  }
+
+  if (type !== 'undefined') {
+    option.default(value.default);
+  }
+
+  createCommand.addOption(option);
+});
+
+createCommand.version(fs.readJSONSync(join(__dirname, '../../package.json')).version);
+
+createCommand.action(async (dirName, options) => {
+  if (options.zip || options.release) {
+    options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
+  }
+
+  startingMessage();
+
+  // NOTE: Default action
+  await createApp(dirName, options);
+});
+
+/**
+ *
+ * @param {import('./flows/lib/manifest').Manifest} manifest
+ */
+const getEnvManagementLink = (manifest) => {
+  if (manifest.isJs()) {
+    if (IS_WINDOWS) {
+      return 'https://github.com/coreybutler/nvm-windows';
+    }
+
+    return 'https://github.com/nvm-sh/nvm';
+  }
+
+  if (IS_WINDOWS) {
+    return 'https://docs.python.org/3/using/windows.html#using-python-on-windows';
+  }
+
+  return 'https://github.com/pyenv/pyenv';
+};
+
+async function initPackage(projectName, opts) {
+  const manifest = new Manifest(fillManifest(opts));
+  const runtime = resolveAppRuntime(opts);
+
+  if (!(await runtime.isRuntimeAvailable())) {
+    throw new StepError(
+      `You need ${runtime.environment} version ${runtime.version} to use "${opts.runtime}" runtime. ` +
+        `Please install it manually or proceed to ${chalk.green(getEnvManagementLink(manifest))} ` +
+        `to install a node version manager`,
+    );
+  }
+
+  if (manifest.isUi()) {
+    await ensureLatestVersion();
+  }
+
+  const root = getRealWorkingDir(projectName, opts);
+
+  logger.log(`Creating a new Corva app in ${chalk.green(root)}.`);
+
+  await fs.ensureDir(root);
+
+  if ((await fs.readdir(root)).length) {
+    const shouldCleanup = await inquirer
+      .prompt([
+        {
+          message: `Directory "${root}" is not empty. Clean it to proceed?`,
+          name: 'cleanup',
+          type: 'confirm',
+        },
+      ])
+      .then(_.get('cleanup'));
+
+    if (shouldCleanup) {
+      await fs.emptyDir(root);
+    } else {
+      throw new StepError(`Directory is not empty: ${root}`);
+    }
+  }
+
+  await fs.writeJSON(join(root, 'manifest.json'), manifest.manifest, WRITE_TO_JSON_OPTS);
+
+  await addTemplate(root, manifest, runtime, opts);
+  await configureApp(root, manifest, runtime, opts);
+
+  if (opts.gitInit) {
+    if (!tryGitInit(root)) {
+      logger.log('Already in a git repository. Skipping git initialization.');
+    }
+  }
+
+  opts.dependenciesInstall && (await installDependencies(root, manifest, runtime));
+
+  if (opts.gitInit) {
+    if (tryGitCommit(root)) {
+      logger.log();
+      logger.log('Created git commit');
+    }
+  }
+
+  logger.log();
+  logger.log(`Success! Created ${chalk.green(manifest.name)} at ${chalk.yellow(root)}`);
+
+  helpCommands(manifest, runtime);
+
+  logger.log();
+}
+
+async function createApp(dirName, opts) {
+  const { isValid, values } = checkOptions(opts);
+
+  if (isValid) {
+    Object.keys(values).forEach((key) => {
+      logger.log(`${key} : ${values[key]}`);
+    });
+
+    return initPackage(dirName, opts);
+  }
+
+  console.log('Please fill your app Metadata');
+
+  const answers = await inquirer.prompt(manifestOptions(dirName), opts);
+
+  return initPackage(dirName, answers);
+}
+
+/**
+ *
+ * @param {string} root
+ * @param {import('./flows/lib/manifest').Manifest} manifest
+ * @param {*} runtime
+ * @param {*} opts
+ */
+async function addTemplate(root, manifest, runtime, opts) {
+  logger.log(chalk.green('Copying app template...'));
+  logger.log();
+
+  const cliRoot = resolve(__dirname, '..', '..');
+
+  const templateFolder = join(cliRoot, 'templates', manifest.templateName, runtime.language);
+
+  const excludeFiles = getExcludedFiles(manifest);
+
+  copyFolderRecursiveSync(templateFolder, root, excludeFiles);
+
+  if (manifest.isNode()) {
+    copyFolderRecursiveSync(join(cliRoot, 'common', 'node'), root);
+  }
+
+  if (manifest.isPython()) {
+    copyFolderRecursiveSync(join(cliRoot, 'common', 'python'), root);
+  }
+
+  if (!manifest.isUi()) {
+    await putVariablesInEnvFile(root, manifest);
+  }
+
+  // We can't have .gitignore file in our templates.
+  // It's missing when @corva/create-app is installed.
+  // That's why we manually rename gitignore to .gitignore after copying template
+  const targetGitignore = join(root, '.gitignore');
+
+  fs.renameSync(join(root, 'gitignore'), targetGitignore);
+
+  if (runtime.language === 'typescript' && manifest.isNode()) {
+    await fs.appendFile(targetGitignore, '\n**/*.js\n');
+  }
+
+  logger.log(chalk.green('Done: copying app template!'));
+
+  try {
+    if (Array.isArray(opts?.extensions) && opts.extensions.length) {
+      opts.extensions.forEach((extension) => {
+        const extPath = join(cliRoot, 'template_extensions', extension);
+
+        if (fs.existsSync(extPath)) {
+          copyFolderRecursiveSync(extPath, root);
+        }
+      });
+
+      logger.log(chalk.green('Done: applying app extensions!'));
+    }
+  } catch (e) {
+    logger.log(chalk.red('Error: applying app extensions!'));
+    logger.log(e);
+  }
+
+  if (manifest.isUi()) {
+    addUiAppFile(templateFolder, root, runtime, manifest, opts);
+  }
+}
+
+/**
+ *
+ * @param {string} root
+ * @param {import('./flows/lib/manifest').Manifest} manifest
+ * @param {*} runtime
+ * @param {*} opts
+ */
+async function configureApp(root, manifest, runtime, opts) {
+  if (manifest.isJs()) {
+    await addNvmRc(root, manifest, runtime);
+    await addPackageJSON(root, manifest, runtime, opts);
+  }
+
+  if (manifest.isNode()) {
+    await addTsConfigs(root, manifest, runtime);
+  }
+
+  if (manifest.isPython()) {
+    await addPythonConfigs(root, manifest, runtime);
+  }
+}
+
+const addNvmRc = async (root, manifest, runtime) => {
+  await fs.outputFile(join(root, '.nvmrc'), `${runtime.semver}\n`);
+};
+
+/**
+ *
+ * @param {string} root
+ * @param {Manifest} manifest
+ * @param {import('../helpers/resolve-app-runtime.js').Runtime} runtime
+ */
+const addPythonConfigs = async (root, manifest, runtime) => {
+  await fs.writeFile(resolve(root, '.python-version'), `${runtime.version}\n`);
+  await fs.writeFile(resolve(root, '.python-virtualenv'), `${manifest.unix_name}\n`);
+};
+
+const addTsConfigs = (root, manifest, runtime) => {
+  if (runtime.language !== 'typescript') {
+    return;
+  }
+
+  return Promise.all([
+    fs.writeJson(
+      resolve(root, 'tsconfig.json'),
+      {
+        extends: `@tsconfig/node${runtime.version}/tsconfig.json`,
+        compilerOptions: {
+          inlineSourceMap: true,
+          strict: false,
+          outDir: 'dist',
+        },
+      },
+      WRITE_TO_JSON_OPTS,
+    ),
+    fs.writeJson(
+      resolve(root, 'tsconfig.build.json'),
+      {
+        extends: './tsconfig.json',
+        include: ['lib/**/*.ts', 'index.ts'],
+        exclude: ['node_modules', '**/*.spec.ts'],
+      },
+      WRITE_TO_JSON_OPTS,
+    ),
+  ]);
+};
+
+/**
+ *
+ * @param {string} root
+ * @param {import('./flows/lib/manifest').Manifest} manifest
+ */
+function addPackageJSON(root, manifest, runtime, opts) {
+  const {
+    version,
+    description,
+    scripts,
+    dependencies,
+    devDependencies,
+    main,
+    license = 'UNLICENSED',
+    private: isPrivate = true,
+    ...rest
+  } = getDefaultsForPackageJson(manifest, runtime, opts);
+
+  const packageJson = {
+    name: manifest.unix_name,
+    version,
+    description: manifest.description || description,
+    main,
+    private: isPrivate,
+    license,
+    engines: {
+      node: `^${runtime.version}`,
+      [runtime.packageManager]: '*',
+    },
+    scripts,
+    dependencies,
+    devDependencies,
+    ...rest,
+  };
+
+  return fs.writeJSON(join(root, 'package.json'), packageJson, WRITE_TO_JSON_OPTS);
+}
+
+/**
+ * @param {string} root
+ * @param {import('./flows/lib/manifest').Manifest} manifest
+ * @param {import('./helpers/resolve-app-runtime.js').Runtime} runtime
+ * @returns {Promise<void>}
+ * @throws {Error}
+ * @throws {import('child_process').ExecException}
+ * @throws {import('child_process').SpawnSyncReturns<Buffer>}
+ */
+async function installDependencies(root, manifest, runtime) {
+  const command = manifest.isJs() ? runtime.packageManager : 'make';
+
+  if (IS_WINDOWS && !manifest.isJs()) {
+    logger.log();
+    logger.log(`⚠️ ${chalk.yellow('Please install project dependencies manually')}`);
+
+    return;
+  }
+
+  const args = ['install'];
+  const opts = { stdio: ['inherit', 'inherit', 'pipe'], cwd: root };
+
+  if (process.env.CI && command === 'yarn') {
+    args.push('--cache-folder=".yarn-cache"');
+  }
+
+  logger.log(chalk.yellow(`Installing template dependencies using ${runtime.packageManager}...`));
+
+  const nvmOpts = {
+    shell: true,
+    ...opts,
+  };
+
+  const proc =
+    manifest.isJs() && existsSync(`${os.homedir()}/.nvm/nvm.sh`)
+      ? spawn.sync(`\\. ${os.homedir()}/.nvm/nvm.sh && nvm i && ${command} ${args.join(' ')}`, nvmOpts)
+      : spawn.sync(command, args, opts);
+
+  if (proc.stderr) {
+    const error = proc.stderr
+      .toString('utf8')
+      .split('\n')
+      // NOTE: filter out warnings caused by @corva/ui peer dependencies
+      .filter((line) => !line.includes('@corva/ui'))
+      .join('\n');
+
+    console.log(error);
+  }
+
+  if (proc.status !== 0) {
+    console.error(`\`${command} ${args.join(' ')}\` failed`);
+
+    return;
+  }
+
+  logger.log(chalk.green('Successfull project install'));
+}
+
+async function helpCommands(manifest, { packageManager: displayedCommand }) {
+  if (!manifest.isUi()) {
+    return;
+  }
+
+  const useYarn = displayedCommand === 'yarn';
+
+  logger.log('Inside that directory, you can run several commands:');
+  logger.log();
+  logger.log(chalk.cyan(`  ${displayedCommand} start`));
+  logger.log('    Starts the development server.');
+  logger.log();
+  logger.log(chalk.cyan(`  ${displayedCommand} ${useYarn ? '' : 'run '}build`));
+  logger.log('    Bundles the app into static files for production.');
+  logger.log();
+  logger.log(chalk.cyan(`  ${displayedCommand} ${useYarn ? '' : 'run '}zip`));
+  logger.log('    Bundles the app into ZIP file in app root directory');
+  logger.log();
+  logger.log(chalk.cyan(`  ${displayedCommand} ${useYarn ? '' : 'run '}release`));
+  logger.log('    Uploads the app ZIP to Corva');
+  logger.log();
+}
+
+function startingMessage() {
+  clear();
+  console.log(chalk.green('   Welcome to apps generator for:'));
+  console.log(chalk.cyan(figlet.textSync('CORVA.AI', { horizontalLayout: 'full' })));
+}
+
+function checkOptions(opts) {
+  let isValid = true;
+  const values = {};
+
+  getManifestMandatoryKeys(opts).forEach((key) => {
+    if (!opts[key]) {
+      isValid = false;
+    }
+
+    values[key] = opts[key];
+  });
+
+  return {
+    isValid,
+    values,
+  };
+}

package/lib/commands/release.js

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import { Command, Option } from 'commander';
+import { runFlow } from '../flow.js';
+import { RELEASE_FLOW } from '../flows/release.js';
+import { getRealWorkingDir } from '../helpers/commands.js';
+import { apiKeyOption } from '../options/api-key.js';
+import { bumpVersionOption } from '../options/bump-version.js';
+import { envOption } from '../options/env.js';
+import { originalCwdOption } from '../options/original-cwd.js';
+import { silentOption } from '../options/silent.js';
+import { ensureBumpVersion } from '../helpers/cli-version.js';
+import { ERROR_ICON } from '../constants/messages.js';
+import { appKeyOption } from '../options/app-key.js';
+
+export const releaseCommand = new Command('release')
+  .description('Release app')
+  .argument('<project-directory>', 'Project directory to work with')
+  .argument('[patterns...]', 'Additional patterns to zip', [])
+  .addOption(bumpVersionOption)
+  .addOption(new Option('--ignored-files [string...]', 'Patterns to skip zip').default([]))
+  .addOption(silentOption)
+  .addOption(envOption)
+  .addOption(apiKeyOption)
+  .addOption(appKeyOption)
+  .addOption(originalCwdOption)
+  .addOption(new Option('--notes [string]', 'Add custom notes to published app'))
+  .addOption(new Option('--label [string]', 'Put a label on the release').choices(['DEV', 'BETA', 'PROD']))
+  .addOption(new Option('--remove-on-fail [boolean]', 'Remove release if it fails during deployment').default(false))
+  .addOption(
+    new Option('--remove-on-success [boolean]', 'App package (.zip) will not be deleted after upload').default(true),
+  )
+  .addOption(
+    new Option(
+      '--remove-existing [boolean]',
+      'If package version is already taken - remove the previously published package and upload a new one',
+    ).default(false),
+  )
+  // .addOption(new Option('--zip-file-name [string]', 'Prebuilt zip file name in dir'))
+  .addOption(new Option('--author [string]', 'Author name for the audit'))
+  .action(async (dirName, patterns, options) => {
+    // if author is present in CLI, save it to process.env
+    if (options.author) {
+      process.env.githubUsername = options.author;
+    }
+
+    options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
+
+    await runFlow(RELEASE_FLOW, {
+      dirName: getRealWorkingDir(dirName, options),
+      patterns,
+      options,
+    });
+  })
+  .showHelpAfterError()
+  .showSuggestionAfterError(true)
+  .configureOutput({
+    outputError: (str, write) => write(chalk.red(`${ERROR_ICON} ${str}`)),
+  });

package/lib/commands/rerun.js

@@ -0,0 +1,34 @@
+import chalk from 'chalk';
+import { Command, Option } from 'commander';
+import { ERROR_ICON } from '../constants/messages.js';
+import { runFlow } from '../flow.js';
+import { RERUN_FLOW } from '../flows/rerun.js';
+import { getRealWorkingDir } from '../helpers/commands.js';
+import { apiKeyOption } from '../options/api-key.js';
+import { appVersion } from '../options/app-version.js';
+import { envOption } from '../options/env.js';
+import { originalCwdOption } from '../options/original-cwd.js';
+import { silentOption } from '../options/silent.js';
+import { cacheOption } from '../options/cache.js';
+
+export const rerunCommand = new Command('rerun')
+  .description('Rerun app')
+  .argument('<project-directory>', 'Project directory to work with')
+  .addOption(apiKeyOption)
+  .addOption(envOption)
+  .addOption(silentOption)
+  .addOption(cacheOption)
+  .addOption(appVersion)
+  .addOption(new Option('--assets [assets...]', 'Assets IDs list', []).conflicts('companyId'))
+  .addOption(new Option('--company-id [number]', 'Company ID', []))
+  .addOption(new Option('--interval [number]', 'Interval for scheduler apps (exp. 1200)'))
+  .addOption(new Option('--force-stream-log-type [string]', 'Force stream log type').choices(['time', 'depth']))
+  .addOption(originalCwdOption)
+  .action(async (dirName, options) => {
+    await runFlow(RERUN_FLOW, { dirName: getRealWorkingDir(dirName, options), options });
+  })
+  .showHelpAfterError()
+  .showSuggestionAfterError(true)
+  .configureOutput({
+    outputError: (str, write) => write(chalk.red(`${ERROR_ICON} ${str}`)),
+  });

package/lib/commands/zip.js

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+import { Command, Option } from 'commander';
+import _ from 'lodash/fp.js';
+
+import { runFlow } from '../flow.js';
+import { ZIP_FLOW } from '../flows/zip.js';
+import { getRealWorkingDir, silencer } from '../helpers/commands.js';
+import { bumpVersionOption } from '../options/bump-version.js';
+import { originalCwdOption } from '../options/original-cwd.js';
+import { silentOption } from '../options/silent.js';
+import { ensureBumpVersion } from '../helpers/cli-version.js';
+import { ERROR_ICON } from '../constants/messages.js';
+
+export const zipCommand = new Command('zip')
+  .description('Bundle app')
+  .argument('<project-directory>', 'Project directory to work with')
+  .argument('[patterns...]', 'Additional patterns to zip', [])
+  .addOption(bumpVersionOption)
+  .addOption(new Option('--ignored-files [ignoredFiles...]', 'Patterns to skip zip', []))
+  .addOption(originalCwdOption)
+  .addOption(silentOption)
+  .action(
+    silencer(async (dirName, patterns, options) => {
+      options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
+
+      console.log(getRealWorkingDir(dirName, options), options);
+
+      return runFlow(ZIP_FLOW, {
+        dirName: getRealWorkingDir(dirName, options),
+        patterns,
+        options,
+      }).then(_.get('zipFileName'));
+    }),
+  )
+  .showHelpAfterError()
+  .showSuggestionAfterError(true)
+  .configureOutput({
+    outputError: (str, write) => write(chalk.red(`${ERROR_ICON} ${str}`)),
+  });

package/lib/constants/cache.js

@@ -0,0 +1,5 @@
+export const DELETE_CACHE_BEHAVIOR = 'delete';
+
+export const OVERRIDE_CACHE_BEHAVIOR = 'override';
+
+export const KEEP_CACHE_BEHAVIOR = 'keep';

package/lib/constants/cli.js

@@ -0,0 +1,35 @@
+export const APP_RUNTIMES = {
+  UI: 'ui',
+  // NODE12: 'nodejs12.x',
+  // NODE14: 'nodejs14.x',
+  // NODE16: 'nodejs16.x',
+  NODE18: 'nodejs18.x',
+  NODE20: 'nodejs20.x',
+  NODE22: 'nodejs22.x',
+  NODE24: 'nodejs24.x',
+  // PYTHON3_8: 'python3.8',
+  // PYTHON3_9: 'python3.9',
+  // PYTHON3_10: 'python3.10',
+  PYTHON3_11: 'python3.11',
+  PYTHON3_12: 'python3.12',
+  PYTHON3_13: 'python3.13',
+};
+
+export const TEMPLATE_TYPES = {
+  UI: 'js',
+  UI_TS: 'ts',
+  NODE: 'node',
+  NODE_TYPESCRIPT: 'node-ts',
+  PYTHON: 'python',
+};
+
+export const APP_TYPES = {
+  UI: 'ui',
+  SCHEDULER: 'scheduler',
+  STREAM: 'stream',
+  TASK: 'task',
+};
+
+export const APP_EXTENSIONS = {
+  CORVA: 'corva',
+};