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

package/README.md

@@ -17,41 +17,184 @@ npm i -g @corva/create-app
 `corva-create-app` provides a user-friendly CLI wizard to create an app.
 
 ```sh
-Usage: corva-create-app <project-directory> [options]
+Usage: create-corva-app [options] [command]
+
+Options:
+  -h, --help                                           display help for command
+
+Commands:
+  create [options] [project-directory]                 Create a new app
+  zip [options] <project-directory> [patterns...]      Bundle app
+  release [options] <project-directory> [patterns...]  Release app
+  help [command]                                       display help for command
+```
+
+## Create an app
+
+To create a new app use `create` command.
+
+```sh
+Usage: create-corva-app create <project-directory> [options]
+
+Create a new app
 
 Arguments:
-  project-directory             project directory to work with
+  project-directory               project directory to work with (default: "Current working dir")
 
 Options:
-  -V, --version                 output the version number
-  -z, --zip <type>              zip app source
-  -t, --useTypescript           use typescript or javascript (default: false)
-  -p, --packageManager <value>  package manager to use (choices: "npm", "yarn", default: "yarn")
-  --appType [value]
-  --appKey [value]
-  --appName [value]
-  --category [value]
-  --segments [value]
-  --runtime [value]
-  -h, --help                    display help for command
+  --developerName [string]        Enter the Developer Name (default: "O&G Company")
+  --developerIdentifier [string]  Enter the Developer Identifier (default: "oandgc")
+  --appType [string]              Choose the App Type (choices: "ui", "scheduler", "stream", "task", default: "ui")
+  --schedulerType [number]        Choose the scheduler type (choices: "1", "2", "4", default: 1)
+  --cronString [string]           Provide CRON string for the scheduler (default: "*/5 * * * *")
+  --depthMilestone [number]       Provide depth milestone for the scheduler (default: 1)
+  --appKey [string]               Enter the App Key (default: "app.key-goes-here")
+  --appName [string]              Enter the App Name
+  --description [string]          Enter description (default: "This is the description of my app. You can do great things with it!")
+  --summary [string]              Enter summary (default: "More information about this app goes here")
+  --category [string]             Enter category (default: "")
+  --website [string]              Enter website (default: "https://www.oandgexample.com/my-app/")
+  --segments [string]             Choose segments (choices: "drilling", "completion")
+  --runtime [string]              Choose runtime (choices: "ui", "nodejs12.x", "nodejs14.x", "python3.8")
+  -p, --packageManager [string]   Please select the desired package manager (choices: "yarn", "npm", default: "yarn")
+  -t, --useTypescript [boolean]   Would you like to use TypesScript? (default: false)
+  -V, --version                   output the version number
+  -z, --zip [string]              DEPRECATED Use zip command instead
+  --release                       DEPRECATED Use release command instead
+  --bump-version <string>         DEPRECATED Use with zip or release command instead (choices: "major", "minor", "patch", "skip")
+  -h, --help                      display help for command
 ```
 
-## Examples
+### Examples
 
-### Create a UI application
+#### Create a UI application
 
 ```sh
 create-corva-app test --appName "Test" --segments "drilling" --category "wellDesign" --appKey "some-company.test.ui" --appType "ui" --runtime "ui"
 ```
 
-### Create a NodeJs TypeScript application
+#### Create a NodeJs TypeScript application
 
 ```sh
 create-corva-app test --appName "Test" --segments "drilling" --category "wellDesign" --appKey "some-company.test.scheduler" --appType "scheduler" --runtime "nodejs12.x" -t
 ```
 
-### Create a Python application
+#### Create a Python application
 
 ```sh
 create-corva-app test --appName "Test" --segments "drilling" --category "analytics" --appKey "some-company.test.stream" --appType "stream" --runtime "python3.8"
 ```
+
+## Zip
+
+To create a zip that contains app ready to be deployed to Corva use `zip` command.
+
+```sh
+Usage: create-corva-app zip [options] <project-directory> [patterns...]
+
+Bundle app
+
+Arguments:
+  project-directory        Project directory to work with
+  patterns                 Additional patterns to zip (default: [])
+
+Options:
+  --bump-version <string>  bump version (choices: "major", "minor", "patch", "skip")
+  -h, --help               display help for command
+```
+
+### What is getting zipped?
+
+By default next files will be included.
+
+For `frontend` apps:
+
+- `manifest.json`
+- `package.json`
+- `yarn.lock`
+- `.npmrc`
+- `config-overrides.js`
+- all files under `src`
+- `tsconfig.json`
+
+For apps that written in `node`:
+
+- `manifest.json`
+- `package.json`
+- either `package-lock.json` or `yarn.lock`
+- all files under `config` folder
+- all `*.js` files under `src` and `lib` folders (if `typescript` is not used)
+- `tsconfig.json`, `tsconfig.build.json` (if `typescript` is used)
+- all `*.ts` files under `src` and `lib` folders (if `typescript` is used)
+
+For apps that written in `python`:
+
+- `manifest.json`
+- `requirements.txt`
+- all `*.py` files
+
+If you want to zip some files that are not included pass that as `patterns` arguments.
+
+### Examples
+
+#### Create a zip file from the content of `test-app` folder & put zip file in it.
+
+```sh
+create-corva-app zip test-app
+```
+
+#### Create a zip file & automatically bump version
+
+```sh
+create-corva-app zip test-app --bump-version=patch
+```
+
+#### Create a zip file from the content of `test-app` folder with custom content ([globs](<https://en.wikipedia.org/wiki/Glob_(programming)>) are supported)
+
+```sh
+create-corva-app zip test-app some/missing/file1 some/other/missing/file2 all/files/*.glob
+```
+
+## Release
+
+To push app to Corva use `release` command.
+
+```sh
+Usage: create-corva-app release [options] <project-directory> [patterns...]
+
+Release app
+
+Arguments:
+  project-directory        Project directory to work with
+  patterns                 Additional patterns to zip (default: [])
+
+Options:
+  --bump-version <string>  bump version (choices: "major", "minor", "patch", "skip")
+  -h, --help               display help for command
+```
+
+### Examples
+
+#### Make a release with ask for version
+
+```sh
+create-corva-app release test-app
+```
+
+#### Make a release without version increase
+
+```sh
+create-corva-app release test-app --bump-version=skip
+```
+
+#### Make a release with increased version
+
+```sh
+create-corva-app release test-app --bump-version=patch
+```
+
+#### Make a release with custom version
+
+```sh
+create-corva-app release test-app --bump-version=4.2.0
+```

package/bin/create-corva-app.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+const { run } = require('../lib/app');
+
+run();

package/lib/app.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const run = () => {
+  require('./');
+};
+
+module.exports = {
+  run,
+};

package/lib/bump-version.option.js

@@ -0,0 +1,29 @@
+const { Option, InvalidArgumentError } = require('commander');
+const chalk = require('chalk');
+
+const flags = '--bump-version <string>';
+const description = 'Bump version';
+const choices = ['major', 'minor', 'patch', 'skip'];
+
+function argParser(value, previous) {
+  if (this.argChoices.includes(value) || semver.valid(value)) {
+    return value;
+  }
+
+  throw new InvalidArgumentError(
+    `Allowed choices are ${this.argChoices
+      .map((choice) => `"${choice}"`)
+      .join(', ')} or a valid semver version.`
+  );
+}
+const bumpVersionOption = new Option(flags, description).choices(choices).argParser(argParser);
+
+const bumpVersionOptionDeprecated = new Option(
+  flags,
+  chalk.bgYellow`DEPRECATED` +
+    ` Use with ${chalk.cyan`zip`} or ${chalk.cyan`release`} command instead`
+)
+  .choices(choices)
+  .argParser(argParser);
+
+module.exports = { bumpVersionOption, bumpVersionOptionDeprecated };

package/{constants → lib/constants}/cli.js

@@ -1,6 +1,7 @@
 const APP_RUNTIMES = {
   UI: 'ui',
   NODE12: 'nodejs12.x',
+  NODE14: 'nodejs14.x',
   PYTHON3: 'python3.8',
 };
 

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

@@ -69,14 +69,6 @@ const defaultDataAppPythonManifest = {
   },
 };
 
-const defaultTimeSchedulerSettings = {
-  cron_string: '*/5 * * * *',
-};
-
-const defaultDepthSchedulerSettings = {
-  depth_milestone: 1,
-};
-
 const getManifestMandatoryKeys = (opts) => {
   const keys = manifestOptions(opts.projectName).reduce((acc, option) => {
     if (option.required) {
@@ -134,14 +126,15 @@ const manifestOptions = (projectName) => [
     name: 'cronString',
     message: 'Provide CRON string for the scheduler',
     default: '*/5 * * * *',
-    when: (answers) => answers.schedulerType && answers.schedulerType !== SCHEDULER_TYPE_DEPTH.value,
+    when: (answers) =>
+      answers.schedulerType && answers.schedulerType !== SCHEDULER_TYPE_DEPTH.value,
   },
   {
     name: 'depthMilestone',
     message: 'Provide depth milestone for the scheduler',
     default: 1,
     when: (answers) => answers.schedulerType === SCHEDULER_TYPE_DEPTH.value,
-    filter: (value) => (isNaN(value) ? value : Number(value))
+    filter: (value) => (isNaN(value) ? value : Number(value)),
   },
   {
     name: 'appKey',
@@ -196,6 +189,7 @@ const manifestOptions = (projectName) => [
     type: 'rawlist',
     name: 'packageManager',
     message: 'Please select the desired package manager',
+    alias: 'p',
     default: 'yarn',
     choices: ['yarn', 'npm'],
     when: (answers) => !answers.runtime || !answers.runtime.startsWith(TEMPLATE_TYPES.PYTHON),
@@ -217,8 +211,6 @@ module.exports = {
   defaultUIAppManifest,
   defaultDataAppNodeManifest,
   defaultDataAppPythonManifest,
-  defaultTimeSchedulerSettings,
-  defaultDepthSchedulerSettings,
   manifestOptions,
   getManifestMandatoryKeys,
   SCHEDULER_TYPE_NATURAL_TIME,

package/lib/constants/messages.js

@@ -0,0 +1,21 @@
+const chalk = require('chalk');
+
+const SUCCESS_ICON = '  ✅  \n';
+const ERROR_ICON = '  ❌  \n';
+
+const RELEASE = {
+  createZip: 'Creating zip archive...\n',
+  createZipError: 'Could not create zip archive.',
+  createZipSuccess: `Zip archive has been created ${SUCCESS_ICON}`,
+  getAuthToken: 'Reading auth token...',
+  getAuthTokenError: `Could not find auth token. For UI app please run ${chalk.cyan`yarn start`} and login to Corva to fetch it.`,
+  getAppKey: 'Reading app key...',
+  getAppKeyError: "Could not find app key. Please make sure it's defined in manifest.json",
+  uploadApp: 'Uploading app...',
+};
+
+module.exports = {
+  RELEASE,
+  SUCCESS_ICON,
+  ERROR_ICON,
+};

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

@@ -38,9 +38,9 @@ const tsDependencies = {
 const scripts = {
   build: 'webpack --config=./config-overrides.js --mode production',
   start: 'webpack-dev-server --config=./config-overrides.js --open --mode development',
-  zip: 'create-corva-app --zip ui',
+  zip: 'create-corva-app zip .',
   lint: 'eslint --cache ./src/',
-  release: 'create-corva-app --release',
+  release: 'create-corva-app release .',
 };
 
 module.exports = {

package/lib/flow.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const chalk = require('chalk');
+const { SUCCESS_ICON } = require('./constants/messages');
+const { resolve, sep } = require('path');
+
+const debug = require('debug')('cca:flow');
+
+const runFlow = async (flow, context, indent = '') => {
+  process.stdout.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);
+
+  return result;
+};
+
+const runSteps = async (steps = [], context = {}, indent = '') => {
+  for (const step of steps) {
+    if (step.name) {
+      const result = await runFlow(step, context, indent);
+
+      Object.assign(context, result);
+
+      continue;
+    }
+
+    const message = indent + step.message;
+
+    process.stdout.write(message);
+    debug('Context: %o', context);
+
+    const result = await step.fn(context);
+
+    Object.assign(context, result);
+
+    process.stdout.write(SUCCESS_ICON);
+  }
+
+  return context;
+};
+
+module.exports = { runFlow };

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

@@ -0,0 +1,77 @@
+const archiver = require('archiver');
+const debug = require('debug')('cca:zip');
+const { promises: fs, createWriteStream } = require('fs');
+const path = require('path');
+
+const createZipArchive = async (dirName, zipName, itemsToZip = []) => {
+  const filePath = path.resolve(dirName, zipName);
+  const archive = archiver.create('zip', {});
+  const output = createWriteStream(filePath);
+  // pipe archive data to the file
+  archive.pipe(output);
+
+  await new Promise(async (resolve, reject) => {
+    output.once('close', resolve).once('end', function () {
+      debug('Data has been drained');
+    });
+
+    archive.on('warning', function (err) {
+      if (err.code === 'ENOENT') {
+        console.warn(err.message);
+
+        return;
+      }
+
+      throw err;
+    });
+
+    archive.once('error', reject);
+
+    const dataToZip = await getDataToZip(itemsToZip, dirName);
+
+    for (const item of dataToZip) {
+      if (item.isDir) {
+        debug(`Adding directory %s -> %s`, item.path, item.name);
+        archive.directory(item.path, item.name);
+
+        continue;
+      }
+
+      debug(`Adding file %s -> %s`, item.path, item.name);
+      archive.file(item.path, { name: item.name });
+    }
+
+    archive.finalize();
+  });
+
+  return archive.pointer();
+};
+
+const getDataToZip = async (itemsToZip, dirName) => {
+  const promises = itemsToZip.map(async (name) => {
+    const nameWasProvided = typeof name === 'string';
+    const filePath = nameWasProvided ? path.resolve(dirName, name) : name.path;
+    const fileName = nameWasProvided ? name : name.name;
+
+    const { exists, isDir } = await fs
+      .lstat(filePath)
+      .then((stat) => ({ exists: true, isDir: stat.isDirectory() }))
+      .catch(() => {
+        debug(`%s location not exist, filtering it out`, filePath);
+
+        return { exists: false, isDir: false };
+      });
+
+    return {
+      name: fileName,
+      path: filePath,
+      exists,
+      isDir,
+    };
+  });
+  const allData = await Promise.all(promises);
+
+  return allData.filter((f) => f.exists);
+};
+
+module.exports = { createZipArchive };

package/lib/flows/lib/json.js

@@ -0,0 +1,28 @@
+const { resolve } = require('path');
+const { promises: fs } = require('fs');
+const os = require('os');
+
+const debug = require('debug')('cca:json');
+
+const loadJson = async (dirName, fileName) => {
+  const fullPath = resolve(dirName, fileName);
+
+  try {
+    debug('Loading file %s', fullPath);
+    const manifest = await fs.readFile(fullPath, 'utf8');
+
+    return JSON.parse(manifest);
+  } catch (e) {
+    if (e.code === 'ENOENT') {
+      throw new Error(`${fileName} was not found in ${resolve(dirName)}`);
+    }
+
+    throw e;
+  }
+};
+
+const saveJson = async (dirName, fileName, data) => {
+  return fs.writeFile(resolve(dirName, fileName), JSON.stringify(data, null, 2) + os.EOL);
+};
+
+module.exports = { loadJson, saveJson };

package/lib/flows/lib/manifest.js

@@ -0,0 +1,31 @@
+const { APP_TYPES, APP_RUNTIMES } = require('../../constants/cli');
+
+const NODE_RUNTIMES = [APP_RUNTIMES.NODE12, APP_RUNTIMES.NODE14];
+
+class Manifest {
+  constructor(manifest) {
+    this.manifest = manifest;
+  }
+
+  get runtime() {
+    return this.manifest.settings.runtime;
+  }
+
+  isNode() {
+    return NODE_RUNTIMES.includes(this.manifest.settings.runtime);
+  }
+
+  isUi() {
+    return this.manifest.application.type === APP_TYPES.UI;
+  }
+
+  isJs() {
+    return this.isUi() || this.isNode();
+  }
+
+  isPython() {
+    return this.manifest.settings.runtime === APP_RUNTIMES.PYTHON3;
+  }
+}
+
+module.exports = { Manifest };

package/lib/flows/lib/step-error.js

@@ -0,0 +1,12 @@
+class StepError extends Error {
+  cause;
+  name;
+
+  constructor(message, { cause } = {}) {
+    super(message);
+    this.name = 'StepError';
+    this.cause = cause;
+  }
+}
+
+module.exports = { StepError };

package/lib/flows/prepare.js

@@ -0,0 +1,8 @@
+const { LOAD_APP_FILES_STEP } = require('./steps/prepare-load-app-files');
+
+const PREPARE_FLOW = {
+  name: 'prepare',
+  steps: [LOAD_APP_FILES_STEP],
+};
+
+module.exports = { PREPARE_FLOW };

package/lib/flows/release.js

@@ -0,0 +1,18 @@
+const { PREPARE_FLOW } = require('./prepare');
+const { GET_APP_KEY_STEP } = require('./steps/release-get-app-key');
+const { GET_RELEASE_CONFIG_STEP } = require('./steps/release-get-config');
+const { UPLOAD_ZIP_TO_CORVA_STEP } = require('./steps/release-upload-zip-to-corva');
+const { ZIP_SIMPLE_FLOW } = require('./zip-simple');
+
+const RELEASE_FLOW = {
+  name: 'release',
+  steps: [
+    PREPARE_FLOW,
+    GET_RELEASE_CONFIG_STEP,
+    GET_APP_KEY_STEP,
+    ZIP_SIMPLE_FLOW,
+    UPLOAD_ZIP_TO_CORVA_STEP,
+  ],
+};
+
+module.exports = { RELEASE_FLOW };

package/lib/flows/steps/prepare-load-app-files.js

@@ -0,0 +1,18 @@
+const { loadJson } = require('../lib/json');
+const { Manifest } = require('../lib/manifest');
+
+const LOAD_APP_FILES_STEP = {
+  message: "Loading Corva app's files...",
+  async fn(context) {
+    const manifest =
+      context.manifest || new Manifest(await loadJson(context.dirName, 'manifest.json'));
+    const pkg =
+      context.package || (manifest.isJs() && (await loadJson(context.dirName, 'package.json')));
+
+    return { pkg, manifest };
+  },
+};
+
+module.exports = {
+  LOAD_APP_FILES_STEP,
+};

package/lib/flows/steps/release-get-app-key.js

@@ -0,0 +1,16 @@
+const { RELEASE } = require('../../constants/messages');
+
+const GET_APP_KEY_STEP = {
+  message: RELEASE.getAppKey,
+  fn: ({ manifest }) => {
+    const appKey = manifest.manifest.application.key;
+
+    if (!appKey) {
+      throw new Error(RELEASE.getAppKeyError);
+    }
+
+    return { appKey };
+  },
+};
+
+module.exports = { GET_APP_KEY_STEP };

package/lib/flows/steps/release-get-config.js

@@ -0,0 +1,30 @@
+const { RELEASE } = require('../../constants/messages');
+const { promises: fs } = require('fs');
+const dotenv = require('dotenv');
+const { resolve } = require('path');
+const { StepError } = require('../lib/step-error');
+
+const GET_RELEASE_CONFIG_STEP = {
+  message: RELEASE.getAuthToken,
+  fn: async ({ dirName }) => {
+    const env = await fs.readFile(resolve(dirName, '.env')).catch((e) => {
+      if (e.code === 'ENOENT') {
+        throw new StepError('Mising .env file', { cause: e });
+      }
+
+      throw e;
+    });
+    const { CORVA_API_ENV, AUTH_TOKEN } = dotenv.parse(env);
+
+    if (!AUTH_TOKEN) {
+      throw new StepError(RELEASE.getAuthTokenError);
+    }
+
+    return {
+      CORVA_API_ENV: CORVA_API_ENV || 'production',
+      AUTH_TOKEN,
+    };
+  },
+};
+
+module.exports = { GET_RELEASE_CONFIG_STEP };

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

@@ -0,0 +1,34 @@
+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 { get } = require('lodash/fp');
+
+const UPLOAD_ZIP_TO_CORVA_STEP = {
+  message: RELEASE.uploadApp,
+  fn: async ({ zipFileName, appKey, CORVA_API_ENV, AUTH_TOKEN, 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: `Bearer ${AUTH_TOKEN}` },
+      })
+      .catch((e) => {
+        throw new StepError(
+          `${get('response.data.message', e) || ''} \nPOST: ${uploadURL} failed.`,
+          { cause: e }
+        );
+      });
+  },
+};
+
+module.exports = { UPLOAD_ZIP_TO_CORVA_STEP };