@corva/create-app 0.39.0-rc.0 → 0.40.0-1

package/README.md

@@ -26,6 +26,7 @@ Commands:
   create [options] [project-directory]                 Create a new app
   zip [options] <project-directory> [patterns...]      Bundle app
   release [options] <project-directory> [patterns...]  Release app
+  rerun [options] <project-directory>                  Rerun app
   help [command]                                       display help for command
 ```
 
@@ -59,6 +60,7 @@ Options:
   --segments [string]             Choose segments (choices: "drilling", "completion")
   --summary [string]              Enter summary (default: "More information about this app goes here")
   --website [string]              Enter website (default: "https://www.oandgexample.com/my-app/")
+  --silent [boolean]              Only log result of the operation
   -V, --version                   output the version number
   -h, --help                      display help for command
   -p, --packageManager [string]   Please select the desired package manager (choices: "yarn", "npm", default: "yarn")
@@ -101,6 +103,7 @@ Arguments:
 
 Options:
   --bump-version <string>  bump version (choices: "major", "minor", "patch", "skip")
+  --silent [boolean]       Only log result of the operation
   -h, --help               display help for command
 ```
 
@@ -172,6 +175,7 @@ Arguments:
 
 Options:
   --bump-version <string>  bump version (choices: "major", "minor", "patch", "skip")
+  --silent [boolean]       Only log result of the operation
   -h, --help               display help for command
 ```
 

package/lib/constants/manifest.js

@@ -204,6 +204,11 @@ const manifestOptions = (projectName = 'Corva Dev Center App') => [
       (answers.runtime && answers.runtime.startsWith(TEMPLATE_TYPES.NODE)) ||
       answers.appType === APP_TYPES.UI,
   },
+  {
+    name: 'silent',
+    message: 'Only log result of the operation',
+    default: false,
+  },
 ];
 
 module.exports = {

package/lib/flow.js

@@ -3,17 +3,18 @@
 const chalk = require('chalk');
 const { SUCCESS_ICON } = require('./constants/messages');
 const { resolve, sep } = require('path');
+const logger = require('./helpers/logger');
 
 const debug = require('debug')('cca:flow');
 
 const runFlow = async (flow, context, indent = '') => {
-  process.stdout.write(
+  logger.write(
     `${indent}Running ${chalk.cyan(flow.name)} in ${chalk.cyan(resolve(context.dirName).split(sep).pop())}\n`
   );
 
   const result = await runSteps(flow.steps, context, indent + '  ');
 
-  process.stdout.write(`${indent}Done!` + SUCCESS_ICON);
+  logger.write(`${indent}Done!` + SUCCESS_ICON);
 
   return result;
 };
@@ -30,14 +31,14 @@ const runSteps = async (steps = [], context = {}, indent = '') => {
 
     const message = indent + step.message;
 
-    process.stdout.write(message);
+    logger.write(message);
     debug('Context: %o', context);
 
     const result = await step.fn(context);
 
     Object.assign(context, result);
 
-    process.stdout.write(SUCCESS_ICON);
+    logger.write(SUCCESS_ICON);
   }
 
   return context;

package/lib/flows/lib/api.js

@@ -0,0 +1,225 @@
+const axios = require('axios');
+
+ /**
+   * Connect to Corva API
+   *
+   */
+class Api {
+  constructor(envName, apiKey, authToken = null) {
+    this.baseURL = `https://api${
+      envName === 'production' ? '' : `.${envName}`
+    }.corva.ai`;
+
+    this.config = {
+      headers: {
+        'Authorization': authToken ? `Bearer ${authToken}` :`API ${apiKey}`,
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+    };
+  }
+
+  /**
+   * Get api url
+   *
+   * @private
+   *
+   * @param {string} path
+   *
+   * @returns  {string}
+   */
+  getUrl(path) {
+    return `${this.baseURL}${path}`;
+  }
+
+  /**
+   * Send api request
+   *
+   * @private
+   *
+   * @param {string} path
+   * @param {string} method
+   * @param {object} data
+   *
+   * @returns  {object}
+   */
+  sendRequest(method, url, data = null) {
+    return data ? axios[method](url, data, this.config) : axios[method](url, this.config);
+  }
+
+  /**
+   * Get app by appKey
+   *
+   * @public
+   *
+   * @param {string} appKey
+   *
+   * @returns  {object}
+   */
+  async getAppByKey(appKey) {
+    const url = this.getUrl(`/v2/apps?per_page=2&search=${appKey}`);
+    const response = await this.sendRequest('get', url);
+
+    const app = response.data.data[0];
+    if (!app || app.attributes.app_key != appKey) {
+      throw new Error(`App with key - ${appKey}, not exist`);
+    }
+
+    return app;
+  }
+
+  /**
+   * Get app datasets
+   *
+   * @public
+   *
+   * @param {string} appId
+   *
+   * @returns  {object}
+   */
+  async getAppDatasetsOperationWrite(appId) {
+    const url = this.getUrl(
+      `/v2/apps/${appId}/app_datasets?dataset_operation=write&fields[]=app_dataset.dataset_name`
+    );
+    const response = await this.sendRequest('get', url);
+
+    if (!response.data.data.length) {
+      throw new Error(`App with ID - ${appId}, has not any datasets`);
+    }
+
+    return response.data.data;
+  }
+
+  /**
+   * Get asset details
+   *
+   * @public
+   *
+   * @param {string} assetId
+   *
+   * @returns  {object[]}
+   */
+  async getAssetById(assetId) {
+    const url = this.getUrl(`/v2/assets/${assetId}`);
+    const response = await this.sendRequest('get', url);
+
+    return response.data.data;
+  }
+
+
+  /**
+   * Get asset streams
+   *
+   * @public
+   *
+   * @param {string} assetId
+   *
+   * @returns  {object[]}
+   */
+   async getStreamByAssetId(assetId) {
+    const url = this.getUrl(`/v1/app_streams?asset_id=${assetId}&segment=drilling&status=complete`);
+    const response = await this.sendRequest('get', url);
+
+    if (!response.data[0]) {
+      throw new Error(`Could not found streams for asset ID - ${assetId}`);
+    }
+
+    return response.data;
+  }
+
+  /**
+   * Get wells data by asset id
+   *
+   * @public
+   *
+   * @param {string} assetId
+   *
+   * @returns  {object[]}
+   */
+  async getWellByAssetId(assetId) {
+    const data = {
+      assets: [assetId],
+    };
+
+    const url = this.getUrl(`/v2/assets/resolve`);
+    const response = await this.sendRequest('post', url, data);
+
+    if (!response.data.wells.length) {
+      throw new Error(`Could not found wells by asset ID - ${assetId}`);
+    }
+
+    return response.data.wells;
+  }
+
+  /**
+   * Queue app run for create new task
+   *
+   * @public
+   *
+   * @param {string} appId
+   * @param {string} version
+   * @param {string} wellId
+   * @param {string[]} appDatasetsNames
+   * @param {string} streamId
+   *
+   * @returns  {object}
+   */
+  async queueAppRun(appId, version, wellId, appDatasetsNames, streamId) {
+    const data = {
+      app_run: {
+        app_stream_id: streamId,
+        well_id: wellId,
+        app_version: version,
+        datasets: appDatasetsNames,
+        settings: {
+          end: 0,
+          interval: null,
+          invokes: null,
+          records_per_event: 300,
+          start: 0,
+        },
+      },
+    };
+
+    const url = this.getUrl(`/v2/apps/${appId}/app_runs`);
+    const response = await this.sendRequest('post', url, data);
+    return response.data.data;
+  }
+
+  /**
+   * Get all active(status - pending or in_progress or running) runs by app ID
+   *
+   * @public
+   *
+   * @param {string} appId
+   *
+   * @returns  {object[]}
+   */
+   async getAppRuns(appId) {
+    const url = this.getUrl(`/v2/apps/${appId}/app_runs?page=1&per_page=500&status[]=pending&status[]=in_progress&status[]=running`);
+    const response = await this.sendRequest('get', url);
+
+    return response.data.data;
+  }
+
+  /**
+   * Upload packages
+   *
+   * @public
+   *
+   * @param {string} appKey
+   * @param {object} formData
+   *
+   * @returns
+   */
+    async uploadPackages(appKey, formData) {
+      const url = this.getUrl(`/v2/apps/${appKey}/packages/upload`);
+      this.config.headers = {
+        ...this.config.headers,
+        ...formData.getHeaders(),
+      };
+      return this.sendRequest('post', url, formData)
+    }
+}
+
+module.exports = { Api };

package/lib/flows/rerun.js

@@ -0,0 +1,10 @@
+const { PREPARE_FLOW } = require('./prepare');
+const { RERUN_STEPS } = require('./steps/rerun');
+const { GET_RELEASE_CONFIG_STEP } = require('./steps/release-get-config');
+
+const RERUN_FLOW = {
+  name: 'rerun',
+  steps: [PREPARE_FLOW, GET_RELEASE_CONFIG_STEP, ...RERUN_STEPS],
+};
+
+module.exports = { RERUN_FLOW };

package/lib/flows/steps/release-upload-zip-to-corva.js

@@ -1,31 +1,19 @@
 const { RELEASE } = require('../../constants/messages');
-const axios = require('axios');
 const FormData = require('form-data');
 const { resolve } = require('path');
 const { createReadStream } = require('fs');
 const { StepError } = require('../lib/step-error');
+const { Api } = require('../lib/api');
 const { get } = require('lodash/fp');
 
 const UPLOAD_ZIP_TO_CORVA_STEP = {
   message: RELEASE.uploadApp,
   fn: async ({ zipFileName, appKey, CORVA_API_ENV, AUTH_TOKEN, API_KEY, dirName }) => {
     const form = new FormData();
-
     form.append('package', createReadStream(resolve(dirName, zipFileName)), 'archive.zip');
 
-    const baseURL = `https://api${
-      CORVA_API_ENV === 'production' ? '' : `.${CORVA_API_ENV}`
-    }.corva.ai`;
-    const uploadURL = `${baseURL}/v2/apps/${appKey}/packages/upload`;
-
-    await axios
-      .post(uploadURL, form, {
-        headers: {
-          ...form.getHeaders(),
-          Authorization: AUTH_TOKEN ? `Bearer ${AUTH_TOKEN}` : `API ${API_KEY}`,
-        },
-      })
-      .catch((e) => {
+    const api = new Api(CORVA_API_ENV, API_KEY, AUTH_TOKEN);
+    api.uploadPackages(appKey, form).catch((e) => {
         throw new StepError(
           `${get('response.data.message', e) || ''} \nPOST: ${uploadURL} failed.`,
           { cause: e }

package/lib/flows/steps/rerun-create-task.js

@@ -0,0 +1,51 @@
+const _ = require('lodash');
+const chalk = require('chalk');
+
+const CREATE_TASK_STEP = {
+  message: 'Creating tasks...',
+  fn: async ({
+    appId,
+    assets,
+    appDatasetsNames,
+    mappedAssetsToStreams,
+    mappedAssetsToWells,
+    api,
+    version,
+    CORVA_API_ENV,
+  }) => {
+    if (!assets.length) {
+      process.stdout.write( 
+        `\n\n${chalk.yellow.bold('There is not a asset ID to create new task')}`
+      );
+    }
+
+    for (const assetId of assets) {
+
+      try {
+        const result = await api.queueAppRun(
+          appId,
+          version,
+          mappedAssetsToWells.get(parseInt(assetId)),
+          appDatasetsNames,
+          mappedAssetsToStreams.get(parseInt(assetId))
+        );
+  
+        process.stdout.write(
+          `\n    Created new task with ID ${chalk.yellow(result.id)} for asset ID - ${chalk.green(
+            assetId
+          )}`
+        );
+
+        process.stdout.write(
+          `\n    Task link - https://app${CORVA_API_ENV === 'production' ? '.' : `.${CORVA_API_ENV}.`}corva.ai/dev-center/apps/${appId}/runner`
+        );
+      } catch (e) {
+        process.stdout.write( 
+          `\n\n${chalk.red.underline.bold(`Could not rerun app for asset ID - ${assetId}, an error occured: ${e.message}`)}\n\n`
+        );
+      }
+    }
+  },
+};
+
+module.exports = { CREATE_TASK_STEP };

package/lib/flows/steps/rerun-prepare-data.js

@@ -0,0 +1,243 @@
+const _ = require('lodash');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { Api } = require('../lib/api');
+const { StepError } = require('../lib/step-error');
+
+const MAX_ASSET_IDS_COUNT = 10;
+
+const PREPARE_DATA_STEP = {
+  message: 'Preparing data for tasks...',
+  fn: async (context) => {
+    const { manifest, patterns, API_KEY, CORVA_API_ENV, pkg } = context;
+    let { assets } = patterns;
+
+    assets = _.uniq(assets);
+
+    if (assets.length > MAX_ASSET_IDS_COUNT) {
+      throw new StepError(`Please no more than ${MAX_ASSET_IDS_COUNT} asset ids!`);
+    }
+
+    if (!['scheduler', 'stream'].includes(manifest.manifest.application.type)) {
+      throw new StepError('Rerun command supports only "scheduler" or "stream" apps');
+    }
+
+    if (!await promptAreYouSure()) {
+      throw new StepError('Command stopped');
+    }
+
+    const api = new Api(CORVA_API_ENV, API_KEY);
+
+    const app = await api.getAppByKey(manifest.manifest.application.key.toLowerCase());
+    const appDatasets = await api.getAppDatasetsOperationWrite(app.id);
+    const appDatasetsNames = appDatasets.map((dataset) => dataset.attributes.dataset_name);
+
+    const existingAppRuns = await getExistAppRuns(app.id, assets, appDatasetsNames, api);
+    if (existingAppRuns.size) {
+      for (let appRunAssetId of existingAppRuns.keys()) {
+        // remove asset ID if similar rerun already exists
+        assets = assets.filter((assetId) => appRunAssetId != assetId);
+
+        const run = existingAppRuns.get(appRunAssetId);
+
+        process.stdout.write( 
+          `\n\n${chalk.yellow.bold(`Similar rerun with ID ${run.id}, for asset ID ${appRunAssetId} - already exist. Will be skipped!`)}`
+        );
+      }
+    }
+
+    const {mappedAssetsToWells, mappedAssetsToStreams, assetsToDelete} = await prepareWellAndStreamData(assets, api);
+
+    if (assetsToDelete.length) {
+      // remove asset ID if could not found stream or well
+      assets = assets.filter((assetId) => !assetsToDelete.includes(assetId));
+    }
+
+    return {
+      appId: app.id,
+      assets,
+      appDatasetsNames,
+      mappedAssetsToStreams,
+      mappedAssetsToWells,
+      api,
+      CORVA_API_ENV,
+      version: pkg.version,
+    };
+  },
+};
+
+/**
+ *  CLI prompt question - Are you sure you want to do this?
+ *
+ * @returns
+ */
+ const promptAreYouSure = async () => {
+    const answers = await inquirer
+      .prompt([
+        {
+          message:
+            '\n This command will create additional load on the server, which may take a long time. \n Are you sure you want to do this?',
+          name: 'option',
+          type: 'list',
+          choices: [
+            { value: true, name: 'Yes' },
+            { value: false, name: 'No' },
+          ],
+          default: false,
+        },
+      ]);
+    return answers.option;
+ }
+
+ /**
+ *  CLI prompt question - Please choose the stream
+ * 
+   * @param {object[]} streams
+ *
+ * @returns
+ */
+  const getStreamWithPrompt = async (streams) => {
+    let stream = {};
+
+    const choices = streams.map((stream) => {
+      return {
+        value: stream,
+        name: stream.name
+      };
+    });
+
+    await inquirer
+      .prompt([
+        {
+          message:
+            '\n Please choose stream?',
+          name: 'option',
+          type: 'list',
+          choices,
+        },
+      ])
+      .then((answers) => {
+        stream = answers.option;
+      });
+
+      return stream;
+ }
+
+ /**
+ *  CLI prompt question - Please choose the well
+ * 
+ * @param {object[]} wells
+ * @param {object} api
+ *
+ * @returns
+ */
+  const getWellWithPrompt = async (wells, api) => {
+    let well = {};
+
+    const choices = await Promise.all(wells.map( async (well) => {
+      const assetDetails = await api.getAssetById(well.data.attributes.asset_id);
+      well.data.name = assetDetails.attributes.name;
+      return {
+        value: well.data,
+        name: well.data.name,
+      };
+    }));
+
+    await inquirer
+      .prompt([
+        {
+          message:
+            '\n Please choose the well?',
+          name: 'option',
+          type: 'list',
+          choices,
+        },
+      ])
+      .then((answers) => {
+        well = answers.option;
+      });
+
+      return well;
+ }
+
+
+ /**
+ *  Get stream and well data for assets
+ * 
+ * @param {string[]} assets
+ * @param {object} api
+ *
+ * @returns {object}
+ */
+  const prepareWellAndStreamData = async (assets, api) => {
+    const mappedAssetsToWells = new Map();
+    const mappedAssetsToStreams = new Map();
+    const assetsToDelete = [];
+
+    for (const assetId of assets) {
+      try {
+        process.stdout.write(
+          `\n\n${chalk.black.underline.bold(`Process asset ID - ${chalk.green(assetId)}`)}`
+        );
+
+        process.stdout.write(
+          '\n    Loading wells...'
+        );
+
+        const wells = await api.getWellByAssetId(assetId);
+        const well = await getWellWithPrompt(wells, api);
+        mappedAssetsToWells.set(well.attributes.asset_id, well.id);
+  
+        process.stdout.write(
+          '\n    Loading streams...'
+        );
+
+        const streams = await api.getStreamByAssetId(assetId);
+        const stream = await getStreamWithPrompt(streams);
+        mappedAssetsToStreams.set(stream.asset_id, stream.id);
+      } catch (e) {
+        process.stdout.write( 
+          `\n\n${chalk.red.underline.bold(`Skipped the asset ID - ${assetId}, an error occured: ${e.message}`)}`
+        );
+
+        assetsToDelete.push(assetId);
+
+        if (mappedAssetsToWells.has(assetId)) mappedAssetsToWells.delete(assetId);
+        if (mappedAssetsToStreams.has(assetId)) mappedAssetsToStreams.delete(assetId);
+      }
+    }
+
+    return {mappedAssetsToWells, mappedAssetsToStreams, assetsToDelete};
+  }
+
+/**
+ *  Check if current runs already exist
+ *
+ * @param {string} appId
+ * @param {string[]} assets
+ * @param {string[]} appDatasetsNames
+ * @param {object} api
+ *
+ * @returns {map}
+ */
+const getExistAppRuns = async (appId, assets, appDatasetsNames, api) => {
+  const appRuns = new Map();
+  const existingAppRuns = await api.getAppRuns(appId);
+
+  // go through all assets ids
+  for (const assetId of assets) {
+    const runsForCurrentAsset = existingAppRuns.filter((run) => run.attributes.well_asset_id == assetId);
+    // go through all existing runs for current asset ID
+    for (const run of runsForCurrentAsset) {
+      const currentAppDatasetsNames = run.attributes.app_run_datasets.map((dataset) => dataset.name);
+      // if datasets names matched for the same asset ID - then run already exist
+      if (appDatasetsNames.sort().toString() === currentAppDatasetsNames.sort().toString()) {
+        appRuns.set(assetId, run);
+      }
+    }
+  }
+
+  return appRuns;
+};
+
+module.exports = { PREPARE_DATA_STEP };

package/lib/flows/steps/rerun.js

@@ -0,0 +1,8 @@
+const { PREPARE_DATA_STEP } = require('./rerun-prepare-data');
+const { CREATE_TASK_STEP } = require('./rerun-create-task');
+
+const RERUN_STEPS = [PREPARE_DATA_STEP, CREATE_TASK_STEP];
+
+module.exports = {
+  RERUN_STEPS,
+};

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

@@ -1,4 +1,5 @@
 const { saveJson } = require('../lib/json');
+const logger = require('../../helpers/logger');
 
 const debug = require('debug')('cca:flow:zip:prepare');
 
@@ -10,7 +11,7 @@ const PREPARE_FILES_BEFORE_ZIP_STEP = {
       await saveJson(dirName, item.name, item.content);
 
       if (item.message) {
-        process.stdout.write(item.message);
+        logger.write(item.message);
       }
     }
   },

package/lib/helpers/logger.js

@@ -0,0 +1,27 @@
+class Logger {
+    constructor() {
+        this.isSilent = process.argv.includes('--silent');
+    }
+
+    write(str) {
+        if (this.isSilent) {
+            return;
+        }
+
+        process.stdout.write(str);
+    }
+
+    writeDirectlyToConsole(str) {
+        process.stdout.write(str);
+    }
+
+    log(str) {
+        if (this.isSilent) {
+            return;
+        }
+
+        console.log(str);
+    }
+}
+
+module.exports = new Logger();

package/lib/helpers/versioning.js

@@ -1,4 +1,5 @@
 const execSync = require('child_process').execSync;
+const logger = require('./logger');
 
 function isInGitRepository(appPath) {
   try {
@@ -20,7 +21,7 @@ function tryGitInit(appPath) {
     execSync('git --version', { stdio: 'ignore', cwd: appPath });
 
     execSync('git init', { stdio: 'ignore', cwd: appPath });
-    console.log('Initialized git repo in app');
+    logger.log('Initialized git repo in app');
     return true;
   } catch (e) {
     console.warn('Git repo not initialized', e);
@@ -35,7 +36,7 @@ function tryGitCommit(appPath) {
       stdio: 'ignore',
       cwd: appPath,
     });
-    console.log('Added first git commit');
+    logger.log('Added first git commit');
     return true;
   } catch (e) {
     // We couldn't commit in already initialized git repo,

package/lib/index.js

@@ -30,11 +30,13 @@ const { runFlow } = require('./flow');
 const { ERROR_ICON } = require('./constants/messages');
 const { StepError } = require('./flows/lib/step-error');
 const { RELEASE_FLOW } = require('./flows/release');
+const { RERUN_FLOW } = require('./flows/rerun');
 const { ZIP_FLOW } = require('./flows/zip');
 const { bumpVersionOptionDeprecated, bumpVersionOption } = require('./bump-version.option');
 const { Manifest } = require('./flows/lib/manifest');
 const { resolveAppRuntime } = require('./helpers/resolve-app-runtime');
 const { existsSync } = require('fs');
+const logger = require('./helpers/logger');
 
 const writejsonOptions = {
   spaces: 2,
@@ -48,11 +50,11 @@ function startingMessage() {
 }
 
 function checkNodeVersion() {
-  process.stdout.write('Checking node version...');
+  logger.write('Checking node version...');
 
   const unsupportedNodeVersion = !semver.satisfies(process.version, '>=16');
   if (unsupportedNodeVersion) {
-    console.log(
+    logger.log(
       chalk.red(
         `\nYou are using Node ${process.version}.\n\n` +
         `Please update to Node 16 or higher for a better, fully supported experience.\n`
@@ -61,7 +63,7 @@ function checkNodeVersion() {
     // Fall back to latest supported react-scripts on Node 4
     return process.exit(1);
   }
-  process.stdout.write('  ✅  \n');
+  logger.write('  ✅  \n');
 }
 
 function checkOptions(opts) {
@@ -179,9 +181,14 @@ async function initialChecks() {
     .argument('[patterns...]', 'Additional patterns to zip', [])
     .addOption(bumpVersionOption)
     .addOption(new Option('--ignored-files [ignoredFiles...]', 'Patterns to skip zip', []))
+    .addOption(new Option('--silent [boolean]', 'Only log result of the operation', []))
     .action(async (dirName, patterns, options) => {
       options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
 
+      if (options.silent) {
+        console.log(dirName);
+      }
+
       return runFlow(ZIP_FLOW, { dirName, patterns, options });
     });
 
@@ -192,12 +199,26 @@ async function initialChecks() {
     .argument('[patterns...]', 'Additional patterns to zip', [])
     .addOption(bumpVersionOption)
     .addOption(new Option('--ignored-files [ignoredFiles...]', 'Patterns to skip zip', []))
+    .addOption(new Option('--silent [boolean]', 'Only log result of the operation', []))
     .action(async (dirName, patterns, options) => {
       options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
 
+      if (options.silent) {
+        console.log(dirName);
+      }
+
       return runFlow(RELEASE_FLOW, { dirName, patterns, options });
     });
 
+  program
+    .command('rerun')
+    .description('Rerun app')
+    .argument('<project-directory>', 'Project directory to work with')
+    .addOption(new Option('--assets [assets...]', 'Assets ids list', []))
+    .action(async (dirName, patterns, options) => {
+      return runFlow(RERUN_FLOW, { dirName, patterns, options });
+    });
+
   try {
     await program.parseAsync(process.argv);
   } catch (e) {
@@ -214,7 +235,7 @@ const handleError = (e) => {
     return;
   }
 
-  process.stdout.write(ERROR_ICON);
+  logger.write(ERROR_ICON);
 
   if (!(e instanceof StepError)) {
     console.error(chalk.red(e));
@@ -235,16 +256,16 @@ const handleCommanderError = (e) => {
         const commandName = program.args[0] || program._defaultCommandName;
 
         console.error('Please specify the project directory:');
-        console.log(
+        logger.log(
           `  ${chalk.cyan(program.name())} ${commandName} ${chalk.green('<project-directory>')}`
         );
-        console.log();
-        console.log('For example:');
-        console.log(
+        logger.log();
+        logger.log('For example:');
+        logger.log(
           `  ${chalk.cyan(program.name())} ${commandName} ${chalk.green('my-react-app')}`
         );
-        console.log();
-        console.log(
+        logger.log();
+        logger.log(
           `Run ${chalk.cyan(`${program.name()} help ${commandName}`)} to see all options.`
         );
       } else {
@@ -278,7 +299,7 @@ async function initPackage(projectName, opts) {
 
   const root = path.resolve(projectName);
 
-  console.log(`Creating a new Corva app in ${chalk.green(root)}.`);
+  logger.log(`Creating a new Corva app in ${chalk.green(root)}.`);
 
   if (fs.existsSync(root)) {
     throw new Error(`Directory already exists: ${root}`);
@@ -290,7 +311,7 @@ async function initPackage(projectName, opts) {
   await configureApp(root, manifest, runtime);
   await installApp(root, manifest, runtime);
 
-  console.log();
+  logger.log();
 }
 
 async function createApp(dirName, opts) {
@@ -298,7 +319,7 @@ async function createApp(dirName, opts) {
 
   if (isValid) {
     Object.keys(values).forEach((key) => {
-      console.log(`${key} : ${values[key]}`);
+      logger.log(`${key} : ${values[key]}`);
     });
 
     return initPackage(dirName, opts);
@@ -318,8 +339,8 @@ async function createApp(dirName, opts) {
  * @param {*} runtime
  */
 async function addTemplate(root, manifest, runtime) {
-  console.log(chalk.green('Copying app template...'));
-  console.log();
+  logger.log(chalk.green('Copying app template...'));
+  logger.log();
 
   const templateFolder = path.resolve(
     __dirname,
@@ -344,7 +365,7 @@ async function addTemplate(root, manifest, runtime) {
   // That's why we manually rename gitignore to .gitignore after copying template
   fs.renameSync(path.join(root, 'gitignore'), path.join(root, '.gitignore'));
 
-  console.log(chalk.green('Done: copying app template!'));
+  logger.log(chalk.green('Done: copying app template!'));
 }
 
 /**
@@ -461,7 +482,7 @@ async function installApp(root, manifest, runtime) {
   const args = ['install'];
   const opts = { stdio: ['inherit', 'inherit', 'pipe'], cwd: root }
 
-  console.log(chalk.yellow(`Installing template dependencies using ${runtime.packageManager}...`));
+  logger.log(chalk.yellow(`Installing template dependencies using ${runtime.packageManager}...`));
   const proc = manifest.isJs() && existsSync(`${os.homedir()}/.nvm/nvm.sh`) ?
     spawn.sync(`\\. ${os.homedir()}/.nvm/nvm.sh && nvm i && ${command} ${args.join(' ')}`, { shell: true, ...opts }) :
     spawn.sync(command, args, opts);
@@ -481,20 +502,20 @@ async function installApp(root, manifest, runtime) {
     return;
   }
 
-  console.log(chalk.green('Successfull project install'));
+  logger.log(chalk.green('Successfull project install'));
 
   if (versioning.tryGitInit(root)) {
-    console.log();
-    console.log('Initialized a git repository.');
+    logger.log();
+    logger.log('Initialized a git repository.');
 
     if (versioning.tryGitCommit(root)) {
-      console.log();
-      console.log('Created git commit.');
+      logger.log();
+      logger.log('Created git commit.');
     }
   }
 
-  console.log();
-  console.log(`Success! Created ${manifest.name} at ${root}`);
+  logger.log();
+  logger.log(`Success! Created ${manifest.name} at ${root}`);
 
   helpCommands(manifest, runtime);
 }
@@ -506,20 +527,20 @@ async function helpCommands(manifest, { packageManager: displayedCommand }) {
 
   const useYarn = displayedCommand === 'yarn';
 
-  console.log('Inside that directory, you can run several commands:');
-  console.log();
-  console.log(chalk.cyan(`  ${displayedCommand} start`));
-  console.log('    Starts the development server.');
-  console.log();
-  console.log(chalk.cyan(`  ${displayedCommand} ${useYarn ? '' : 'run '}build`));
-  console.log('    Bundles the app into static files for production.');
-  console.log();
-  console.log(chalk.cyan(`  ${displayedCommand} ${useYarn ? '' : 'run '}zip`));
-  console.log('    Bundles the app into ZIP file in app root directory');
-  console.log();
-  console.log(chalk.cyan(`  ${displayedCommand} ${useYarn ? '' : 'run '}release`));
-  console.log('    Uploads the app ZIP to Corva');
-  console.log();
+  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();
 }
 
 initialChecks();

package/lib/scripts/utils/version.js

@@ -3,6 +3,7 @@ const chalk = require('chalk');
 const semver = require('semver');
 const inquirer = require('inquirer');
 
+const logger = require('../../helpers/logger');
 const packageJson = require('../../../package.json');
 const npm = new NpmApi();
 
@@ -37,7 +38,7 @@ async function ensureLatestVersion() {
 
 // NOTE: Show user-friendly warning if version is outdated
 async function warnIfOutdated() {
-  process.stdout.write('Checking for updates...\n');
+  logger.write('Checking for updates...\n');
 
   const currentVersion = getCurrentVersion();
   const latestVersion = await getLatestVersion();
@@ -55,7 +56,7 @@ async function warnIfOutdated() {
     `);
     console.log(warning(asterisks));
   } else {
-    process.stdout.write('  ✅  \n');
+    logger.write('  ✅  \n');
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@corva/create-app",
-    "version": "0.39.0-rc.0",
+    "version": "0.40.0-1",
     "private": false,
     "description": "Create app to use it in CORVA.AI",
     "keywords": [