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

package/lib/flows/lib/manifest.js

@@ -0,0 +1,47 @@
+const { APP_TYPES, APP_RUNTIMES, TEMPLATE_TYPES } = 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;
+  }
+
+  get type() {
+    return this.manifest.application.type
+  }
+
+  get name() {
+    return this.manifest.application.name
+  }
+
+  get description() {
+    return this.manifest.application.description
+  }
+
+  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;
+  }
+
+  isScheduler() {
+    return this.manifest.application.type === APP_TYPES.SCHEDULER;
+  }
+}
+
+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 };

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

@@ -0,0 +1,17 @@
+const { promises: fs } = require('fs');
+const { resolve } = require('path');
+
+const debug = require('debug')('cca:flow:zip:cleanup');
+
+const CLEANUP_STEP = {
+  message: 'Removing temporary files...',
+  fn: async ({ itemsToRemove, dirName }) => {
+    for (const item of itemsToRemove) {
+      debug('Removing %s', item);
+
+      await fs.unlink(resolve(dirName, item));
+    }
+  },
+};
+
+module.exports = { CLEANUP_STEP };

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

@@ -0,0 +1,15 @@
+const { createZipArchive } = require('../lib/create-zip-archive');
+const debug = require('debug')('cca:flow:zip:archive');
+
+const CREATE_ARCHIVE_STEP = {
+  message: 'Creating archive...',
+  fn: async ({ itemsToZip, zipFileName, dirName }) => {
+    debug(`Zipping %d items to %s`, itemsToZip.length, zipFileName);
+
+    const bytes = await createZipArchive(dirName, zipFileName, itemsToZip);
+
+    debug(`Created %s with %d items (%d bytes)`, zipFileName, itemsToZip.length, bytes);
+  },
+};
+
+module.exports = { CREATE_ARCHIVE_STEP };

package/lib/flows/steps/zip-file-list-resolve.js

@@ -0,0 +1,185 @@
+const { set } = require('lodash/fp');
+const { resolve } = require('path');
+const { promises: fs } = require('fs');
+const Glob = require('glob');
+const chalk = require('chalk');
+const isGlob = require('is-glob');
+const { promisify } = require('util');
+const { getIncreasedVersion } = require('../../scripts/utils/version');
+const { loadJson } = require('../lib/json');
+const { StepError } = require('../lib/step-error');
+
+const glob = promisify(Glob);
+const debug = require('debug')('cca:flow:zip:resolve');
+
+const uniqueValues = (array) => Array.from(new Set(array));
+
+const FILE_LIST_RESOLVE_STEP = {
+  message: 'Resolving files list...',
+  fn: async (context) => {
+    const { patterns, manifest, dirName } = context;
+    const files = await transformPatternsIntoFileNames(dirName, patterns);
+
+    if (manifest.isUi()) {
+      return resolveDataToZipUiApp(files, context);
+    }
+
+    if (manifest.isNode()) {
+      return resolveDataForZipNodeJsApp(files, context);
+    }
+
+    if (manifest.isPython()) {
+      return resolveDataForZipPythonApp(files, context);
+    }
+
+    throw new Error(`Unsupported runtime: ${manifest.runtime}`);
+  },
+};
+
+const transformPatternsIntoFileNames = async (dirName, patterns) => {
+  const filesFromPatterns = [];
+
+  for (const pattern of patterns) {
+    if (pattern.includes('node_modules')) {
+      debug('Invalid file pattern', pattern);
+
+      continue;
+    }
+
+    if (!isGlob(pattern, { strict: false })) {
+      filesFromPatterns.push(pattern);
+
+      continue;
+    }
+
+    const files = await glob(pattern, { cwd: dirName, ignore: '**/node_modules' });
+
+    filesFromPatterns.push(...files);
+  }
+
+  return filesFromPatterns;
+};
+
+const resolveDataToZipUiApp = async (itemsToZip = [], { options, pkg, dirName }) => {
+  const version = await getIncreasedVersion(pkg.version, options);
+  const zipFileName = `${pkg.name}-${version}.zip`;
+  const itemsToSave = [];
+  const shouldUpdateVersion = version !== pkg.version;
+
+  if (shouldUpdateVersion) {
+    pkg.version = version;
+
+    itemsToSave.push({
+      name: 'package.json',
+      content: pkg,
+      message: chalk(
+        `\n${chalk.yellow`NOTE`}: Version of your app was updated to ${version} (package.json), please don't lower it.`
+      ),
+    });
+  }
+
+  itemsToSave.push({
+    name: 'packageForSource.json',
+    content: set(
+      'scripts',
+      {
+        build: 'webpack --config=./config-overrides.js --mode production',
+      },
+      pkg
+    ),
+  });
+
+  const itemsToRemove = ['packageForSource.json'];
+
+  itemsToZip.push(
+    'manifest.json',
+    'config-overrides.js',
+    'tsconfig.json',
+    '.npmrc',
+    'yarn.lock',
+    { path: resolve(dirName, 'packageForSource.json'), name: 'package.json' },
+    'src'
+  );
+
+  return {
+    zipFileName,
+    itemsToZip,
+    itemsToSave,
+    itemsToRemove,
+  };
+};
+
+const resolveDataForZipNodeJsApp = async (itemsToZip = [], { options, pkg, dirName }) => {
+  const version = await getIncreasedVersion(pkg.version, options);
+  const zipFileName = `${pkg.name}-${version}.zip`;
+  const itemsToSave = [];
+  const shouldUpdateVersion = version !== pkg.version;
+
+  if (shouldUpdateVersion) {
+    pkg.version = version;
+
+    itemsToSave.push({
+      name: 'package.json',
+      content: pkg,
+      message: chalk(
+        `\n${chalk.yellow`NOTE`}: Version of your app was updated to ${version} (package.json), please don't lower it.`
+      ),
+    });
+  }
+
+  const packageDirContent = await fs.readdir(dirName);
+  const shouldPushDefaultSrc = !itemsToZip.length;
+
+  itemsToZip.push('config', 'manifest.json', 'package.json');
+
+  if (packageDirContent.includes('package-lock.json')) {
+    itemsToZip.push('package-lock.json');
+
+    if (shouldUpdateVersion) {
+      itemsToSave.push({
+        name: 'package-lock.json',
+        content: set('version', version, await loadJson(dirName, 'package-lock.json')),
+      });
+    }
+  } else if (packageDirContent.includes('yarn.lock')) {
+    itemsToZip.push('yarn.lock');
+  } else {
+    throw new StepError(`No lock file found in ${dirName}`);
+  }
+
+  if (packageDirContent.includes('tsconfig.json')) {
+    itemsToZip.push('tsconfig.json', 'tsconfig.build.json');
+
+    if (shouldPushDefaultSrc) {
+      itemsToZip.push('index.ts', ...(await glob('+(src|lib)/**/*.ts', { cwd: dirName })));
+    }
+  } else if (shouldPushDefaultSrc) {
+    itemsToZip.push('index.js', ...(await glob('+(src|lib)/**/*.js', { cwd: dirName })));
+  }
+
+  return {
+    zipFileName,
+    itemsToZip: uniqueValues(itemsToZip),
+    itemsToSave,
+    itemsToRemove: [],
+  };
+};
+
+const resolveDataForZipPythonApp = async (itemsToZip = [], { manifest, dirName }) => {
+  const zipFileName = `${manifest.manifest.application.name}.zip`;
+
+  if (!itemsToZip.length) {
+    itemsToZip.push(...(await glob('**/*.py', { cwd: dirName })));
+  }
+
+  itemsToZip.push('manifest.json', 'requirements.txt');
+
+  return {
+    zipFileName,
+    itemsToZip: uniqueValues(itemsToZip),
+    itemsToSave: [],
+    itemsToRemove: [],
+  };
+};
+
+module.exports = { FILE_LIST_RESOLVE_STEP };

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

@@ -0,0 +1,21 @@
+const { saveJson } = require('../lib/json');
+
+const debug = require('debug')('cca:flow:zip:prepare');
+
+const PREPARE_FILES_BEFORE_ZIP_STEP = {
+  message: 'Preparing...',
+  fn: async ({ itemsToSave, dirName }) => {
+    for (const item of itemsToSave) {
+      debug(`Updating %s`, item.name);
+      await saveJson(dirName, item.name, item.content);
+
+      if (item.message) {
+        process.stdout.write(item.message);
+      }
+    }
+  },
+};
+
+module.exports = {
+  PREPARE_FILES_BEFORE_ZIP_STEP,
+};

package/lib/flows/steps/zip.js

@@ -0,0 +1,15 @@
+const { CLEANUP_STEP } = require('./zip-cleanup');
+const { CREATE_ARCHIVE_STEP } = require('./zip-create-archive');
+const { FILE_LIST_RESOLVE_STEP } = require('./zip-file-list-resolve');
+const { PREPARE_FILES_BEFORE_ZIP_STEP } = require('./zip-prepare');
+
+const ZIP_STEPS = [
+  FILE_LIST_RESOLVE_STEP,
+  PREPARE_FILES_BEFORE_ZIP_STEP,
+  CREATE_ARCHIVE_STEP,
+  CLEANUP_STEP,
+];
+
+module.exports = {
+  ZIP_STEPS,
+};

package/lib/flows/zip-simple.js

@@ -0,0 +1,8 @@
+const { ZIP_STEPS } = require('./steps/zip');
+
+const ZIP_SIMPLE_FLOW = {
+  name: 'zip (simple)',
+  steps: ZIP_STEPS,
+};
+
+module.exports = { ZIP_SIMPLE_FLOW };

package/lib/flows/zip.js

@@ -0,0 +1,9 @@
+const { PREPARE_FLOW } = require('./prepare');
+const { ZIP_STEPS } = require('./steps/zip');
+
+const ZIP_FLOW = {
+  name: 'zip',
+  steps: [PREPARE_FLOW, ...ZIP_STEPS],
+};
+
+module.exports = { ZIP_FLOW };

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

@@ -34,11 +34,11 @@ function fillManifest(answers) {
     settings: {
       ...defaultManifestProperties.settings,
       runtime,
-      ...defaultAppSettings({
+      app: defaultAppSettings({
         type: answers.appType,
         schedulerType: answers.schedulerType,
         cronString: answers.cronString,
-        depthMilestone: answers.depthMilestone
+        depthMilestone: answers.depthMilestone,
       }),
     },
   };
@@ -63,19 +63,17 @@ function defaultAppSettings({ type, schedulerType, cronString, depthMilestone })
     return {};
   }
 
-  const schedulerAppSettings =
-    schedulerType === manifestConstants.SCHEDULER_TYPE_DEPTH.value
-      ? manifestConstants.defaultDepthSchedulerSettings
-      : manifestConstants.defaultTimeSchedulerSettings;
+  if (schedulerType === manifestConstants.SCHEDULER_TYPE_DEPTH.value) {
+    return {
+      scheduler_type: schedulerType,
+      depth_milestone: depthMilestone || 1
+    }
+  }
 
   return {
-    app: {
-      ...schedulerAppSettings,
-      scheduler_type: schedulerType,
-      cron_string: cronString,
-      depth_milestone: depthMilestone
-    },
-  };
+    scheduler_type: schedulerType,
+    cron_string: cronString || '*/5 * * * *',
+  }
 }
 
 module.exports = {

package/lib/helpers/resolve-app-runtime.js

@@ -0,0 +1,29 @@
+const { APP_TYPES } = require("../constants/cli");
+
+const resolveAppRuntime = (opts) => {
+  if (opts.appType === APP_TYPES.UI) {
+    return {
+      language: opts.useTypescript ? "typescript" : "javascript",
+      packageManager: opts.packageManager,
+      version: process.version.replace(/^v/, ""),
+    }
+  }
+
+  if (opts.runtime.startsWith('node')) {
+    const version = /nodejs(\d{2})\.x/.exec(opts.runtime)[1];
+
+    return {
+      language: opts.useTypescript ? "typescript" : "javascript",
+      packageManager: opts.packageManager,
+      version
+    }
+  }
+
+  return {
+    language: "python",
+    packageManager: 'pip',
+    version: '3.8'
+  }
+};
+
+module.exports = { resolveAppRuntime };

package/{helpers → lib/helpers}/utils.js

@@ -13,29 +13,29 @@ function copyFileSync(source, target) {
   fs.writeFileSync(targetFile, fs.readFileSync(source));
 }
 
-function copyFolderRecursiveSync(source, target, excludeFolderName) {
-  let files = [];
-
+function copyFolderRecursiveSync(sourceFolder, targetFolder) {
   //check if folder needs to be created or integrated
-  let targetFolder;
-  if (path.basename(source) !== excludeFolderName) {
-    targetFolder = path.join(target, path.basename(source));
-  } else targetFolder = target;
   if (!fs.existsSync(targetFolder)) {
     fs.mkdirSync(targetFolder);
   }
 
+  if (!fs.lstatSync(sourceFolder).isDirectory()) {
+    return;
+  }
+
   //copy
-  if (fs.lstatSync(source).isDirectory()) {
-    files = fs.readdirSync(source);
-    files.forEach(function (file) {
-      const curSource = path.join(source, file);
-      if (fs.lstatSync(curSource).isDirectory()) {
-        copyFolderRecursiveSync(curSource, targetFolder, excludeFolderName);
-      } else {
-        copyFileSync(curSource, targetFolder);
-      }
-    });
+  const items = fs.readdirSync(sourceFolder);
+
+  for (const item of items) {
+    const curSource = path.join(sourceFolder, item);
+
+    if (fs.lstatSync(curSource).isDirectory()) {
+      copyFolderRecursiveSync(curSource, path.join(targetFolder, item));
+
+      continue;
+    }
+
+    copyFileSync(curSource, targetFolder);
   }
 }