@corva/create-app 0.12.0-1 → 0.12.0-2

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [0.12.0-2](https://github.com/corva-ai/create-corva-app/compare/v0.12.0-1...v0.12.0-2) (2021-09-21)
+
+
+### Features
+
+* add typescript app templates ([f256b39](https://github.com/corva-ai/create-corva-app/commit/f256b3970b4a2f426c6f87ddd10fe5c957757658))
+* **DC-2167:** updated node templates to use latest sdk ([#118](https://corvaqa.atlassian.net/browse/118)) ([c9dc93a](https://github.com/corva-ai/create-corva-app/commit/c9dc93a07a48b06f4c0831bcd95aca4fd5b5504c))
+
 ## [0.12.0-1](https://github.com/corva-ai/create-corva-app/compare/v0.12.0-0...v0.12.0-1) (2021-09-20)
 
 

package/README.md

@@ -1,32 +1,57 @@
-# create-corva-app
+# @corva/create-app
+
+Apps generator for [corva.ai](https://corva.ai).
+
+## Prerequisites
+
+- NodeJs 12+ (https://nodejs.org/en/download/)
 
 ## Installation
 
-```
+```sh
 npm i -g @corva/create-app
 ```
 
-# Usage
+## Usage
 
 `corva-create-app` provides a user-friendly CLI wizard to create an app.
 
 ```sh
 Usage: corva-create-app <project-directory> [options]
 
+Arguments:
+  project-directory             project directory to work with
+
 Options:
-  -V, --version       output the version number
-  -z, --zip <type>    zip app source
+  -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          output usage information
+  -h, --help                    display help for command
 ```
 
-Example:
+## Examples
+
+### 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
+
+```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
+
+```sh
+create-corva-app test --appName "Test" --segments "drilling" --category "analytics" --appKey "some-company.test.stream" --appType "stream" --runtime "python3.8"
+```

package/constants/manifest.js

@@ -79,20 +79,66 @@ const defaultDepthSchedulerSettings = {
 
 const MANIFEST_MANDATORY_KEYS = ['appType', 'appKey', 'appName', 'category', 'segments', 'runtime'];
 
-const manifestOptions = {
-  developerName: 'O&G Company',
-  developerIdentifier: 'oandgc',
-  appType: ['ui', 'scheduler', 'stream', 'task'],
-  appKey: 'app.key-goes-here',
-  appName: 'Name of My App',
-  description: 'This is the description of my app. You can do great things with it!',
-  summary: 'More information about this app goes here',
-  category: '',
-  website: 'https://www.oandgexample.com/my-app/',
-  segments: ['drilling', 'completion'],
-  runtime: ['ui', 'python3.8', 'nodejs12.x'],
-  schedulerType: ['data_time', 'data_depth', 'natural_time'],
-};
+const manifestOptions = (projectName) => [
+  { name: 'developerName', message: 'Enter the Developer Name', default: 'O&G Company' },
+  { name: 'developerIdentifier', message: 'Enter the Developer Identifier', default: 'oandgc' },
+  {
+    type: 'rawlist',
+    name: 'appType',
+    message: 'Choose the App Type',
+    default: 'ui',
+    choices: ['ui', 'scheduler', 'stream', 'task'],
+  },
+  { name: 'appKey', message: 'Enter the App Key', default: 'app.key-goes-here' },
+  { name: 'appName', message: 'Enter the App Name', default: projectName },
+  {
+    name: 'description',
+    message: 'Enter description',
+    default: 'This is the description of my app. You can do great things with it!',
+  },
+  {
+    name: 'summary',
+    message: 'Enter summary',
+    default: 'More information about this app goes here',
+  },
+  { name: 'category', message: 'Enter category', default: '' },
+  { name: 'website', message: 'Enter website', default: 'https://www.oandgexample.com/my-app/' },
+  {
+    type: 'rawlist',
+    name: 'segments',
+    message: 'Choose segments',
+    choices: ['drilling', 'completion'],
+  },
+  {
+    type: 'rawlist',
+    name: 'runtime',
+    message: 'Choose runtime',
+    choices: ['python3.8', 'nodejs12.x'],
+    when: (answers) => answers.appType !== 'ui',
+  },
+  {
+    type: 'rawlist',
+    name: 'packageManager',
+    message: 'Please select the desired package manager',
+    default: 'yarn',
+    choices: ['yarn', 'npm'],
+    when: (answers) => !answers.runtime || !answers.runtime.startsWith('python'),
+  },
+  {
+    type: 'confirm',
+    name: 'useTypescript',
+    message: 'Would you like to use TypesScript?',
+    default: false,
+    when: (answers) => answers.runtime && answers.runtime.startsWith('nodejs'),
+  },
+  {
+    type: 'rawlist',
+    name: 'schedulerType',
+    message: 'Choose schedulerType',
+    choices: ['data_time', 'data_depth', 'natural_time'],
+    when: (answers) => answers.appType === 'scheduler',
+  },
+];
 
 module.exports = {
   defaultManifest,

package/helpers/manifest.js

@@ -1,9 +1,12 @@
 const manifestConstants = require('../constants/manifest.js');
 
 function fillManifest(answers) {
+  const runtime = answers.runtime || 'ui';
+
   const defaultManifestProperties = _defaultManifestProperties({
     type: answers.appType,
-    runtime: answers.runtime,
+    // fallback to UI
+    runtime,
   });
 
   const manifest = {
@@ -29,7 +32,7 @@ function fillManifest(answers) {
     },
     settings: {
       ...defaultManifestProperties.settings,
-      runtime: answers.runtime,
+      runtime,
       ...defaultAppSettings({ type: answers.appType, schedulerType: answers.schedulerType }),
     },
   };
@@ -50,21 +53,21 @@ function _defaultManifestProperties({ type, runtime }) {
 }
 
 function defaultAppSettings({ type, schedulerType }) {
-  if (type === 'scheduler') {
-    const schedulerAppSettings =
-      schedulerType == 'data_depth'
-        ? manifestConstants.defaultDepthSchedulerSettings
-        : manifestConstants.defaultTimeSchedulerSettings;
-
-    return {
-      app: {
-        ...schedulerAppSettings,
-        scheduler_type: schedulerType || 'data_time',
-      },
-    };
+  if (!schedulerType) {
+    return {};
   }
 
-  return {};
+  const schedulerAppSettings =
+    schedulerType == 'data_depth'
+      ? manifestConstants.defaultDepthSchedulerSettings
+      : manifestConstants.defaultTimeSchedulerSettings;
+
+  return {
+    app: {
+      ...schedulerAppSettings,
+      scheduler_type: schedulerType || 'data_time',
+    },
+  };
 }
 
 module.exports = {

package/index.js

@@ -14,7 +14,6 @@ const semver = require('semver');
 const uiScripts = require('./scripts/ui');
 const { ensureLatestVersion } = require('./scripts/utils/version');
 const utils = require('./helpers/utils.js');
-const metadata = require('./helpers/metadata.js');
 const manifestHelpers = require('./helpers/manifest.js');
 const versioning = require('./helpers/versioning.js');
 
@@ -25,6 +24,15 @@ const packageJson = require('./package.json');
 const { clear } = require('console');
 const spawn = require('cross-spawn');
 
+const YARN_EXECUTABLE = 'yarn';
+
+let packageManager = YARN_EXECUTABLE;
+let useTypescript = false;
+
+const shouldUseYarn = () => packageManager === YARN_EXECUTABLE;
+const getLockFileName = (manager) =>
+  manager === YARN_EXECUTABLE ? 'yarn.lock' : 'package-lock.json';
+
 clear();
 
 let projectName;
@@ -55,15 +63,16 @@ function checkNodeVersion() {
   }
 }
 
-function checkArguments() {
+function checkOptions(opts) {
   let isValid = true;
   const values = {};
 
   manifestConstants.MANIFEST_MANDATORY_KEYS.forEach((key) => {
-    if (!program[key]) {
+    if (!opts[key]) {
       isValid = false;
     }
-    values[key] = program[key];
+
+    values[key] = opts[key];
   });
 
   return {
@@ -73,15 +82,22 @@ function checkArguments() {
 }
 
 async function initialChecks() {
-  program = new commander.Command(packageJson.name)
+  startingMessage();
+
+  program = new commander.Command('corva-create-app')
     .version(packageJson.version)
-    .arguments('<project-directory>')
+    .argument('[project-directory]', 'project directory to work with')
     .usage(`${chalk.green('<project-directory>')} [options]`)
     .action((name) => {
       projectName = name;
     })
-    .on('--help', helpCommands)
-    .option('-z, --zip <type>', 'zip app source');
+    .option('-z, --zip <type>', 'zip app source')
+    .option('-t, --useTypescript', 'use typescript or javascript', false)
+    .addOption(
+      new commander.Option(`-p, --packageManager <value>`, 'package manager to use')
+        .default(YARN_EXECUTABLE)
+        .choices(['npm', YARN_EXECUTABLE])
+    );
 
   manifestConstants.MANIFEST_MANDATORY_KEYS.forEach((key) => {
     program.option(`--${key} [value]`);
@@ -91,16 +107,20 @@ async function initialChecks() {
 
   checkNodeVersion();
 
-  if (program.zip) {
-    if (program.zip === APP_TYPES.UI) return uiScripts.zipAppSource();
+  const opts = program.opts();
+
+  packageManager = opts.packageManager || packageManager;
+  useTypescript = opts.useTypescript || useTypescript;
+
+  if (opts.zip) {
+    if (opts.zip === APP_TYPES.UI) {
+      return uiScripts.zipAppSource(shouldUseYarn());
+    }
 
     process.exit(0);
   }
 
-  // NOTE: Default action
-  await createApp();
-
-  if (typeof projectName === 'undefined') {
+  if (!projectName) {
     console.error('Please specify the project directory:');
     console.log(`  ${chalk.cyan(program.name())} ${chalk.green('<project-directory>')}`);
     console.log();
@@ -110,6 +130,9 @@ async function initialChecks() {
     console.log(`Run ${chalk.cyan(`${program.name()} --help`)} to see all options.`);
     process.exit(1);
   }
+
+  // NOTE: Default action
+  await createApp(opts);
 }
 
 async function initPackage(manifest) {
@@ -134,6 +157,10 @@ async function initPackage(manifest) {
       runtime = 'python';
     } else if (runtime.startsWith('nodejs')) {
       runtime = 'node';
+
+      if (useTypescript) {
+        runtime += '-ts';
+      }
     }
   }
 
@@ -142,49 +169,29 @@ async function initPackage(manifest) {
   installApp(root, appType, runtime);
 }
 
-function fillAppMETA() {
-  console.log('Please fill your app Metadata');
-
-  const prompts = Object.keys(manifestConstants.manifestOptions).map((key) => ({
-    type: metadata.getType(manifestConstants.manifestOptions[key]),
-    name: key,
-    message: `${
-      typeof manifestConstants.manifestOptions[key] === 'string' ? 'Enter' : 'Choose'
-    } ${key}`,
-    default: manifestConstants.manifestOptions[key],
-    choices: metadata.getChoices(manifestConstants.manifestOptions[key]),
-  }));
-
-  inquirer.prompt(prompts).then((answers) => {
-    const manifest = manifestHelpers.fillManifest(answers);
-    initPackage(manifest);
-  });
-}
-
-async function createApp() {
-  const { isValid, values } = checkArguments();
 
-  startingMessage();
+async function createApp(opts) {
+  const { isValid, values } = checkOptions(opts);
 
   if (isValid) {
     Object.keys(values).forEach((key) => {
       console.log(`${key} : ${values[key]}`);
     });
+
     const manifest = manifestHelpers.fillManifest(values);
+
     await initPackage(manifest);
   } else {
-    inquirer
-      .prompt([
-        {
-          name: 'appName',
-          message: 'Enter app name:',
-          default: projectName,
-        },
-      ])
-      .then((answers) => {
-        console.info('App Name:', answers.appName);
-        fillAppMETA();
-      });
+    console.log('Please fill your app Metadata');
+
+    inquirer.prompt(manifestConstants.manifestOptions(projectName)).then((answers) => {
+      packageManager = answers.packageManager || packageManager;
+      useTypescript = answers.useTypescript || useTypescript;
+
+      const manifest = manifestHelpers.fillManifest(answers);
+
+      initPackage(manifest);
+    });
   }
 
   console.log();
@@ -196,19 +203,23 @@ function addTemplate(root, appType, runtime) {
 
   let templateFolder = path.resolve(__dirname, 'template', appType);
   let nameExclusion = appType;
+
   if (appType !== APP_TYPES.UI) {
     templateFolder = path.resolve(__dirname, 'template', appType, runtime);
+
     nameExclusion = runtime;
   }
-  console.log(templateFolder);
+
   utils.copyFolderRecursiveSync(templateFolder, root, nameExclusion);
 
-  if (appType === APP_TYPES.UI) {
+  const gitignore = path.join(root, 'gitignore');
+
+  if (fs.pathExistsSync(gitignore)) {
     // 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
 
-    fs.renameSync(path.join(root, 'gitignore'), path.join(root, '.gitignore'));
+    fs.renameSync(gitignore, path.join(root, '.gitignore'));
   }
 
   console.log(chalk.green('Done: copying app template!'));
@@ -217,8 +228,8 @@ function addTemplate(root, appType, runtime) {
 function configureApp(root, appType, runtime, manifest) {
   if (appType === APP_TYPES.UI) {
     addPackageJSON(root, manifest.application.name);
-  } else if (runtime === APP_TYPES.NODE) {
-    updatePackageJSON(root, manifest.application.name, appType, runtime);
+  } else if (runtime.startsWith(APP_TYPES.NODE)) {
+    updatePackageJSON(root, manifest.application.description, appType, runtime);
   }
 }
 
@@ -234,36 +245,40 @@ function addPackageJSON(root, appName) {
   fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify(packageJson, null, 2) + os.EOL);
 }
 
-function updatePackageJSON(root, appName, appType, runtime) {
+function updatePackageJSON(root, description, appType, runtime) {
   const templateFolder = path.resolve(__dirname, 'template', appType, runtime);
 
   let packageJson = JSON.parse(fs.readFileSync(path.join(templateFolder, 'package.json'), 'utf-8'));
 
-  packageJson.name = appName.replace(/\W/g, '');
+  packageJson.name = projectName.replace(/\W/g, '-').toLowerCase();
+  packageJson.description = description;
+
+  packageJson.scripts.bundle = packageJson.scripts.bundle.replace(
+    '$LOCKFILE',
+    getLockFileName(packageManager)
+  );
 
   fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify(packageJson, null, 2) + os.EOL);
 }
 
 function installApp(appPath, appType, runtime) {
-  switch (appType) {
-    case 'ui':
-      installUIApp(appPath);
+  switch (runtime) {
+    case 'python': {
       break;
+    }
+    default: {
+      installJsApp(appPath, appType);
+
+      break;
+    }
   }
 }
 
-function installUIApp(appPath) {
-  let command;
-  let args;
-  const useYarn = true;
-
-  //@TODO: Add npm support
-  if (useYarn) {
-    command = 'yarn';
-    args = ['install'];
-  }
+function installJsApp(appPath, appType) {
+  const command = packageManager;
+  const args = ['install'];
 
-  console.log(chalk.yellow('Installing template dependencies using yarn...'));
+  console.log(chalk.yellow(`Installing template dependencies using ${command}...`));
   const proc = spawn.sync(command, args, { stdio: 'inherit', cwd: appPath });
 
   if (proc.status !== 0) {
@@ -287,14 +302,16 @@ function installUIApp(appPath) {
 
   console.log();
   console.log(`Success! Created ${projectName} at ${appPath}`);
-  console.log('Inside that directory, you can run several commands:');
-  helpCommands();
-}
 
-function helpCommands() {
-  const useYarn = true;
+  if (appType === APP_TYPES.UI) {
+    console.log('Inside that directory, you can run several commands:');
+    helpCommands();
+  }
+}
 
-  const displayedCommand = useYarn ? 'yarn' : 'npm';
+async function helpCommands() {
+  const displayedCommand = packageManager;
+  const useYarn = shouldUseYarn();
 
   console.log();
   console.log(chalk.cyan(`  ${displayedCommand} start`));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@corva/create-app",
-    "version": "0.12.0-1",
+    "version": "0.12.0-2",
     "private": false,
     "description": "Create app to use it in CORVA.AI",
     "keywords": [
@@ -34,7 +34,7 @@
     "dependencies": {
         "archiver": "^5.0.0",
         "chalk": "4.1.0",
-        "commander": "4.1.0",
+        "commander": "^8.2.0",
         "conventional-changelog-cli": "^2.1.0",
         "cross-spawn": "7.0.3",
         "envinfo": "7.5.1",

package/scripts/ui/zipAppSource.js

@@ -7,7 +7,7 @@ const semverInc = require('semver/functions/inc');
 
 const { warnIfOutdated } = require('../utils/version');
 
-async function compressAppToZip() {
+async function compressAppToZip(useYarn) {
   warnIfOutdated();
 
   const dirname = process.cwd();
@@ -72,7 +72,7 @@ async function compressAppToZip() {
 
   console.log(
     chalk(`
-    NOTE: Version of you app was updated to ${updatedVersion} (package.json), please don't lower it.
+    NOTE: Version of your app was updated to ${updatedVersion} (package.json), please don't lower it.
   `)
   );
 
@@ -85,8 +85,8 @@ async function compressAppToZip() {
     name: 'package.json',
   });
 
-  ['manifest.json', 'config-overrides.js', 'yarn.lock'].forEach((name) =>
-    archive.file(path.resolve(dirname, name), { name })
+  ['manifest.json', 'config-overrides.js', useYarn ? 'yarn.lock' : 'package-lock.json'].forEach(
+    (name) => archive.file(path.resolve(dirname, name), { name })
   );
 
   archive.directory(path.resolve(dirname, 'src'), 'src');

package/template/scheduler/node/__test__/processor.test.js

@@ -1,8 +1,8 @@
 const Processor = require('../src/processor');
-const loggerFactory = require('@corva/node-logger');
 
 test('process event', async () => {
-  const logger = loggerFactory();
+  const fakeLogger = console;
+  const fakeApiClient = {};
 
   const event = {
     company: 1,
@@ -13,7 +13,7 @@ test('process event', async () => {
     schedule_end: 157829400000,
   };
 
-  const processor = new Processor({ logger });
+  const processor = new Processor({ logger: fakeLogger, apiClient: fakeApiClient });
 
   await processor.process({ event });
 });

package/template/scheduler/node/gitignore

@@ -0,0 +1,21 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+
+# testing
+/coverage
+
+# misc
+.env
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+*.zip

package/template/scheduler/node/package.json

@@ -4,14 +4,14 @@
     "description": "My Dev Center Polling Scheduler Data App",
     "main": "index.js",
     "scripts": {
-        "bundle": "zip -r $npm_package_name-$npm_package_version.zip package.json package-lock.json manifest.json index.js src",
+        "bundle": "zip -r $npm_package_name-$npm_package_version.zip package.json $LOCKFILE manifest.json index.js src",
         "test": "npm audit --production && npm run unit",
         "unit": "jest"
     },
     "dependencies": {
-        "@corva/node-sdk": "^1.5.5"
+        "@corva/node-sdk": "^5.3.1"
     },
     "devDependencies": {
-        "jest": "^26.6.3"
+        "jest": "^27.2.0"
     }
 }

package/template/scheduler/node-ts/README.md

@@ -0,0 +1,25 @@
+# Dev Center Node.js TypeScript Polling Scheduler Data App
+
+## Getting started
+
+### 1. Install Dependencies
+
+```
+npm install
+```
+
+### 2. Run Tests
+
+```
+npm test
+```
+
+### 3. Build
+
+```
+npm run build
+```
+
+### 4. Deploy
+
+Run `npm run bundle` to create a zip package that can be uploaded to Dev Center

package/template/scheduler/node-ts/__test__/processor.spec.ts

@@ -0,0 +1,20 @@
+import { Processor } from '../lib/processor';
+import type { HandlerContext, ScheduledLambdaEvent } from '@corva/node-sdk';
+
+test('process event', async () => {
+  const fakeLogger = console as unknown as HandlerContext['logger'];
+  const fakeApiClient = {} as unknown as HandlerContext['api'];
+
+  const event = {
+    company: 1,
+    asset_id: 1234,
+    schedule: 206977482,
+    interval: 300,
+    schedule_start: 157829100000,
+    schedule_end: 157829400000,
+  } as unknown as ScheduledLambdaEvent<any>;
+
+  const processor = new Processor(fakeApiClient, fakeLogger);
+
+  await processor.process(event);
+});