@corva/create-app 0.28.0-0 → 0.28.0-3

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) {
@@ -111,7 +103,7 @@ const SCHEDULER_TYPE_NATURAL_TIME = { name: 'Natural Time', value: 1 };
 const SCHEDULER_TYPE_DATA_TIME = { name: 'Data Time', value: 2 };
 const SCHEDULER_TYPE_DEPTH = { name: 'Date Depth', value: 4 };
 
-const manifestOptions = (projectName) => [
+const manifestOptions = (projectName = 'Corva Dev Center App') => [
   { name: 'developerName', message: 'Enter the Developer Name', default: 'O&G Company' },
   { name: 'developerIdentifier', message: 'Enter the Developer Identifier', default: 'oandgc' },
   {
@@ -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/lib/constants/package.js

@@ -0,0 +1,161 @@
+const uiDependencies = {
+  '@corva/ui': 'latest',
+  '@material-ui/core': '4.11.2',
+  '@material-ui/icons': '4.9.1',
+  '@material-ui/lab': '4.0.0-alpha.57',
+  '@material-ui/pickers': '3.2.10',
+  'classnames': '2.2.6',
+  'corva-convert-units': '1.10.17',
+  'highcharts': '8.1.2',
+  'highcharts-react-official': '2.2.2',
+  'lodash': '^4.17.4',
+  'mapbox.js': '3.2.1',
+  'moment': '2.23.0',
+  'moment-timezone': '0.5.23',
+  'prop-types': '^15.6.1',
+  'react': '17.0.1',
+  'react-dom': '17.0.1',
+}
+
+const jsUiDevDependencies = {
+  'postcss-loader': '4.1.0',
+}
+
+const tsUiDevDependencies = {
+  '@tsconfig/create-react-app': '1.0.2',
+  '@types/material-ui': '0.21.9',
+  '@types/react': '^17.0.22',
+  '@types/react-dom': '^17.0.9',
+  '@typescript-eslint/eslint-plugin': '^4.31.2',
+  '@typescript-eslint/parser': '^4.31.2',
+  'ts-loader': '8.2.0',
+  'typescript': '^4.4.3',
+};
+
+const uiScripts = {
+  build: 'webpack --config=./config-overrides.js --mode production',
+  start: 'webpack-dev-server --config=./config-overrides.js --open --mode development',
+  zip: 'create-corva-app zip .',
+  lint: 'eslint --cache ./src/',
+  release: 'create-corva-app release .',
+};
+
+const uiPackage = {
+  version: '0.0.1',
+  main: 'src/index.js',
+  scripts: uiScripts,
+  dependencies: uiDependencies,
+  devDependencies: jsUiDevDependencies
+}
+
+const tsUiPackage = {
+  ...uiPackage,
+  devDependencies: tsUiDevDependencies
+}
+
+const nodeNpmScripts = {
+  "bundle": "create-corva-app zip .",
+  "test": "npm audit --production && npm run unit",
+  "unit": "jest --passWithNoTests"
+};
+
+const nodeDependencies = {
+  "@corva/node-sdk": "^6.2.0"
+}
+
+const nodeDevDependencies = {
+  "jest": "^27.5.1"
+}
+
+const nodeTsDevDependencies = {
+  "@types/jest": "^27.4.1",
+  "jest": "^27.5.1",
+  "ts-jest": "^27.1.4",
+  "typescript": "^4.6.3"
+}
+
+const nodeYarnScripts = {
+  ...nodeNpmScripts,
+  "test": "yarn audit --groups dependencies && yarn unit",
+}
+
+const nodeTsScripts = {
+  ...nodeNpmScripts,
+  "build": "tsc -p tsconfig.build.json",
+}
+
+const nodeTsYarnScripts = {
+  ...nodeYarnScripts,
+  "build": "tsc -p tsconfig.build.json",
+}
+
+const nodeNpmPackage = {
+  version: '0.0.1',
+  main: 'index.js',
+  private: true,
+  dependencies: nodeDependencies,
+  devDependencies: nodeDevDependencies,
+  scripts: nodeNpmScripts
+}
+
+const nodeYarnPackage = {
+  ...nodeNpmPackage,
+  scripts: nodeYarnScripts
+}
+
+const nodeTsNpmPackage = {
+  ...nodeNpmPackage,
+  devDependencies: nodeTsDevDependencies,
+  scripts: nodeTsScripts
+}
+
+const nodeTsYarnPackage = {
+  ...nodeTsNpmPackage,
+  scripts: nodeTsYarnScripts
+}
+
+const extendWithTsConfig = (package, version) => {
+  package.devDependencies = {
+    [`@tsconfig/node${version}`]: `^${version === '12' ? '1.0.9' : '1.0.1'}`,
+    ...package.devDependencies,
+  };
+
+  return package;
+}
+
+const defaults = {
+  javascript: {
+    yarn: {
+      ui: () => uiPackage,
+      task: () => nodeYarnPackage,
+      scheduler: () => nodeYarnPackage,
+      stream: () => nodeYarnPackage
+    },
+    npm: {
+      ui: () => uiPackage,
+      task: () => nodeNpmPackage,
+      scheduler: () => nodeNpmPackage,
+      stream: () => nodeNpmPackage
+    },
+  },
+  typescript: {
+    yarn: {
+      ui: () => tsUiPackage,
+      task: ({ version }) => extendWithTsConfig(nodeTsYarnPackage, version),
+      scheduler: ({ version }) => extendWithTsConfig(nodeTsYarnPackage, version),
+      stream: ({ version }) => extendWithTsConfig(nodeTsYarnPackage, version)
+    },
+    npm: {
+      ui: () => tsUiPackage,
+      task: ({ version }) => extendWithTsConfig(nodeTsNpmPackage, version),
+      scheduler: ({ version }) => extendWithTsConfig(nodeTsNpmPackage, version),
+      stream: ({ version }) => extendWithTsConfig(nodeTsNpmPackage, version)
+    }
+  }
+};
+
+module.exports = {
+  getDefaultsForPackageJson: (manifest, runtime) => {
+    return defaults[runtime.language][runtime.packageManager][manifest.type](runtime);
+  }
+}

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 };