@corva/create-app 0.0.0-73c49372

package/lib/flows/lib/waitForMs.js

@@ -0,0 +1,3 @@
+export async function waitForMs(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/lib/flows/prepare.js

@@ -0,0 +1,6 @@
+import { LOAD_APP_FILES_STEP } from './steps/prepare-load-app-files.js';
+
+export const PREPARE_FLOW = {
+  name: 'prepare',
+  steps: [LOAD_APP_FILES_STEP],
+};

package/lib/flows/release.js

@@ -0,0 +1,26 @@
+import { PREPARE_FLOW } from './prepare.js';
+import { SETUP_API_CLIENT_STEP } from './steps/release/get-config.js';
+import { UPLOAD_ZIP_TO_CORVA_STEP } from './steps/release/upload-zip-to-corva.js';
+import { ZIP_SIMPLE_FLOW } from './zip-simple.js';
+import { WAIT_FOR_BUILD_FINISH_STEP } from './steps/release/wait-for-build.js';
+import { REMOVE_FAILED_UPLOAD_STEP } from './steps/release/remove-failed-upload.js';
+import { ADD_LABEL_STEP } from './steps/release/add-label.js';
+import { ADD_NOTES_STEP } from './steps/release/add-notes.js';
+import { PUBLISH_PACKAGE_STEP } from './steps/release/publish.js';
+import { RELEASE_PREPARE_DATA_STEP } from './steps/release/prepare-data.js';
+
+export const RELEASE_FLOW = {
+  name: 'release',
+  steps: [
+    PREPARE_FLOW,
+    SETUP_API_CLIENT_STEP,
+    RELEASE_PREPARE_DATA_STEP,
+    ZIP_SIMPLE_FLOW,
+    UPLOAD_ZIP_TO_CORVA_STEP,
+    WAIT_FOR_BUILD_FINISH_STEP,
+    REMOVE_FAILED_UPLOAD_STEP,
+    PUBLISH_PACKAGE_STEP,
+    ADD_LABEL_STEP,
+    ADD_NOTES_STEP,
+  ],
+};

package/lib/flows/rerun.js

@@ -0,0 +1,8 @@
+import { PREPARE_FLOW } from './prepare.js';
+import { RERUN_STEPS } from './steps/rerun/rerun.js';
+import { SETUP_API_CLIENT_STEP } from './steps/release/get-config.js';
+
+export const RERUN_FLOW = {
+  name: 'rerun',
+  steps: [PREPARE_FLOW, SETUP_API_CLIENT_STEP, ...RERUN_STEPS],
+};

package/lib/flows/steps/attach/add-app-to-stream.js

@@ -0,0 +1,23 @@
+export const ADD_APP_TO_STREAM_TASK_STEP = {
+  message: 'Add app to streams...',
+  fn: async (context) => {
+    const { assetsStreamsDataToProcess, api, app, manifest, notification } = context;
+
+    let counter = 0;
+
+    for (const assetStreamsData of assetsStreamsDataToProcess) {
+      for (const stream of assetStreamsData.selectedStreams) {
+        notification.printStreamLink(stream.name, stream.id);
+
+        try {
+          await api.connectAppToStream(app.id, stream.id, manifest.manifest.settings.app);
+          ++counter;
+        } catch (e) {
+          notification.printError(`Could not add app to the stream, an error occurred: ${e.message}`);
+        }
+      }
+    }
+
+    notification.print(`The app has been added to ${counter} - stream(s)`);
+  },
+};

package/lib/flows/steps/attach/get-all-live-assets.js

@@ -0,0 +1,135 @@
+import inquirer from 'inquirer';
+
+export const GET_ALL_LIVE_ASSETS_TASK_STEP = {
+  message: 'Fetching all live assets information...',
+  fn: async (context) => {
+    const { manifest, api, app, notification } = context;
+
+    const assets = await api.getAllAssets();
+
+    notification.print(`${assets.length} - asset was found`);
+
+    const selectedAssets = await getAssetsListWithPrompt(assets, notification);
+
+    const assetsIds = selectedAssets.map((asset) => asset.id);
+    const streams = await api.getStreamsByAssetIds(assetsIds, manifest.manifest.application.segments);
+
+    const mappedAssetStreamsData = mapAssetsStreamsData(selectedAssets, streams);
+
+    const assetsStreamsDataToProcess = await getAssetsStreamsWithPrompt(mappedAssetStreamsData, app.id, notification);
+
+    return {
+      ...context,
+      assetsStreamsDataToProcess,
+    };
+  },
+};
+
+/**
+ *  CLI get assets list
+ *
+ * @param {object[]} assets
+ * @param {import('../../lib/notification').Notification} notification
+ *
+ * @returns {Promise<object[]>}
+ */
+const getAssetsListWithPrompt = (assets, notification) => {
+  const choices = assets.map((asset) => {
+    return {
+      value: asset,
+      name: notification.getAssetLink(asset.attributes.name, asset.id),
+      checked: true,
+    };
+  });
+
+  return inquirer
+    .prompt([
+      {
+        message: 'Please choose assets?',
+        name: 'option',
+        type: 'checkbox',
+        choices,
+      },
+    ])
+    .then((res) => res.option);
+};
+
+/**
+ *  Map asset and stream data
+ *
+ * @param {object[]} assets
+ * @param {object[]} streamsData
+ *
+ * @returns {object[]}
+ */
+const mapAssetsStreamsData = (assets, streamsData) => {
+  return assets.map((asset) => {
+    const currentStreams = streamsData.filter((stream) => stream.asset_id === parseInt(asset.id));
+
+    return {
+      assetId: asset.id,
+      assetName: asset.attributes.name,
+      streams: currentStreams,
+      selectedStreams: [],
+    };
+  });
+};
+
+/**
+ *  CLI get streams list to process
+ *
+ * @param {object[]} mappedAssetsStreamsData
+ * @param {number} appId
+ * @param {import('../../lib/notification').Notification} notification
+ *
+ * @returns {Promise<object[]>}
+ */
+const getAssetsStreamsWithPrompt = async (mappedAssetsStreamsData, appId, notification) => {
+  notification.printLineBreak();
+
+  for (const mappedData of mappedAssetsStreamsData) {
+    const currentStreamsCount = mappedData.streams.length;
+
+    if (!currentStreamsCount) {
+      continue;
+    }
+
+    const streamsWithoutCurrentApp = mappedData.streams.filter((stream) => {
+      return !stream.app_connections.find((appConnection) => appConnection.app_id === parseInt(appId));
+    });
+
+    if (!streamsWithoutCurrentApp.length) {
+      continue;
+    }
+
+    if (streamsWithoutCurrentApp.length === 1) {
+      mappedData.selectedStreams = streamsWithoutCurrentApp;
+
+      continue;
+    }
+
+    const choices = streamsWithoutCurrentApp.map((stream) => {
+      return {
+        value: stream,
+        name: notification.getStreamLink(stream.name, stream.id),
+        checked: true,
+      };
+    });
+
+    const link = notification.getAssetLink(mappedData.assetName, mappedData.assetId);
+    const selectedStreams = await inquirer
+      .prompt([
+        {
+          message: `Please choose streams for the asset - ${link}?`,
+          name: 'option',
+          type: 'checkbox',
+          choices,
+        },
+      ])
+      .then((res) => res.option);
+
+    mappedData.selectedStreams = selectedStreams;
+  }
+
+  return mappedAssetsStreamsData;
+};

package/lib/flows/steps/attach/index.js

@@ -0,0 +1,5 @@
+import { PREPARE_DATA_TASK_STEP } from './prepare-data.js';
+import { GET_ALL_LIVE_ASSETS_TASK_STEP } from './get-all-live-assets.js';
+import { ADD_APP_TO_STREAM_TASK_STEP } from './add-app-to-stream.js';
+
+export const ATTACH_STEPS = [PREPARE_DATA_TASK_STEP, GET_ALL_LIVE_ASSETS_TASK_STEP, ADD_APP_TO_STREAM_TASK_STEP];

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

@@ -0,0 +1,19 @@
+import { StepError } from '../../lib/step-error.js';
+
+export const PREPARE_DATA_TASK_STEP = {
+  message: 'Preparing and checking data...',
+  fn: async (context) => {
+    const { manifest, api } = context;
+
+    if (!['scheduler', 'stream'].includes(manifest.manifest.application.type)) {
+      throw new StepError('Command supports only "scheduler" or "stream" apps');
+    }
+
+    const app = await api.getAppByKey(manifest.manifest.application.key);
+
+    return {
+      app,
+      ...context,
+    };
+  },
+};

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

@@ -0,0 +1,12 @@
+import { loadJson } from '../lib/json.js';
+import { Manifest } from '../lib/manifest.js';
+
+export 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 };
+  },
+};

package/lib/flows/steps/release/add-label.js

@@ -0,0 +1,10 @@
+export const ADD_LABEL_STEP = {
+  message: 'Adding label...',
+  async fn({ options: { label }, api, appId, packageId }) {
+    if (!label) {
+      return;
+    }
+
+    await api.putLabel(appId, packageId, label);
+  },
+};

package/lib/flows/steps/release/add-notes.js

@@ -0,0 +1,10 @@
+export const ADD_NOTES_STEP = {
+  message: 'Adding notes...',
+  async fn({ api, appId, packageId, options: { notes } }) {
+    if (!notes) {
+      return;
+    }
+
+    await api.addNotes(appId, packageId, notes);
+  },
+};

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

@@ -0,0 +1,41 @@
+import { RELEASE } from '../../../constants/messages.js';
+import { promises as fs } from 'node:fs';
+import dotenv from 'dotenv';
+import { resolve } from 'node:path';
+import { StepError } from '../../lib/step-error.js';
+import { Api } from '../../lib/api.js';
+import { Notification } from '../../lib/notification.js';
+
+async function getVarsFromDotEnv({ dirName }) {
+  try {
+    const envFile = await fs.readFile(resolve(dirName, '.env'));
+
+    return dotenv.parse(envFile);
+  } catch (error) {
+    return {};
+  }
+}
+
+export const SETUP_API_CLIENT_STEP = {
+  message: RELEASE.getAuthToken,
+  fn: async ({ dirName, options: { apiKey, env } }) => {
+    const parsedEnv = await getVarsFromDotEnv({ dirName });
+
+    const CORVA_API_ENV = env || parsedEnv.CORVA_API_ENV || process.env.CORVA_API_ENV || 'production';
+    const AUTH_TOKEN = process.env.AUTH_TOKEN || parsedEnv.AUTH_TOKEN;
+    const API_KEY = apiKey || process.env.API_KEY || parsedEnv.API_KEY;
+
+    if (!AUTH_TOKEN && !API_KEY) {
+      throw new StepError(RELEASE.getAuthTokenError);
+    }
+
+    const api = new Api(CORVA_API_ENV, API_KEY, AUTH_TOKEN);
+    const notification = new Notification(CORVA_API_ENV);
+
+    return {
+      CORVA_API_ENV,
+      api,
+      notification,
+    };
+  },
+};

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

@@ -0,0 +1,12 @@
+export const RELEASE_PREPARE_DATA_STEP = {
+  message: 'Preparing data...',
+  async fn({ api, manifest, options }) {
+    const appKey = options.appKey || manifest.manifest.application.key;
+    const app = await api.getAppByKey(appKey);
+
+    return {
+      appId: app.id,
+      appKey,
+    };
+  },
+};

package/lib/flows/steps/release/publish.js

@@ -0,0 +1,11 @@
+export const PUBLISH_PACKAGE_STEP = {
+  message: 'Publishing app...',
+  /**
+   *
+   * @param {object} param0
+   * @param {import('../../lib/api').Api} param0.api
+   */
+  async fn({ api, appId, packageId }) {
+    await api.publishApp(appId, packageId);
+  },
+};

package/lib/flows/steps/release/remove-failed-upload.js

@@ -0,0 +1,21 @@
+import { resolve } from 'node:path';
+import { unlink } from 'node:fs/promises';
+import { StepError } from '../../lib/step-error.js';
+
+export const REMOVE_FAILED_UPLOAD_STEP = {
+  message: 'Cleaning up...',
+  async fn({ api, appId, packageId, removeOnFail, uploadStatus, dirName, zipFileName, removeOnSuccess }) {
+    if (uploadStatus === 'draft') {
+      removeOnSuccess && (await unlink(resolve(dirName, zipFileName)));
+
+      return;
+    }
+
+    if (removeOnFail) {
+      await unlink(resolve(dirName, zipFileName));
+      await api.deleteAppUpload(appId, packageId);
+    }
+
+    throw new StepError(`Got unexpected status '${uploadStatus}' while processing package ${packageId}.`);
+  },
+};

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

@@ -0,0 +1,62 @@
+import FormData from 'form-data';
+import chalk from 'chalk';
+import { createReadStream } from 'node:fs';
+import { resolve } from 'node:path';
+import { RELEASE } from '../../../constants/messages.js';
+import { StepError } from '../../lib/step-error.js';
+import { logger } from '../../../helpers/logger.js';
+
+async function deleteAppPackage({ api, appId, appPkgVersion }) {
+  const appPackages = await api.getAppPackages(appId);
+  const packageToDelete = appPackages.find(
+    (appPackage) => appPackage.attributes.package_code_version === appPkgVersion,
+  );
+
+  if (!packageToDelete) {
+    throw new StepError('No matching version while trying to remove the existing package, unrecoverable error');
+  }
+
+  try {
+    await api.deleteAppUpload(appId, packageToDelete?.id);
+  } catch (error) {
+    throw new StepError('Failed to remove the package, probably can retry');
+  }
+}
+
+export const UPLOAD_ZIP_TO_CORVA_STEP = {
+  message: RELEASE.uploadApp,
+  /**
+   *
+   * @param {object} param0
+   * @param {import('../../lib/api').Api} param0.api
+   */
+  fn: async ({ zipFileName, api, appId, appKey, dirName, options, pkg }) => {
+    async function uploadAppPackage() {
+      const form = new FormData();
+
+      form.append('package', createReadStream(resolve(dirName, zipFileName)), 'package.zip');
+
+      const { id: packageId, isDeletedDueToLimit } = await api.uploadPackages(appKey, form);
+
+      if (isDeletedDueToLimit) {
+        logger.write(
+          `\n${chalk.yellow`NOTE`}: Version number limit reached. The oldest version without label was deleted.`,
+        );
+      }
+
+      return { packageId };
+    }
+
+    try {
+      return await uploadAppPackage();
+    } catch (error) {
+      if (error?.message?.includes('Package code version has already been taken') && options.removeExisting) {
+        await deleteAppPackage({ api, appPkgVersion: pkg.version, appId });
+
+        return uploadAppPackage();
+      }
+
+      throw error;
+    }
+  },
+};

package/lib/flows/steps/release/wait-for-build.js

@@ -0,0 +1,36 @@
+import debugFn from 'debug';
+import { waitForMs } from '../../lib/waitForMs.js';
+import { logger } from '../../../helpers/logger.js';
+
+const debug = debugFn('cca:flow:release:step:wait-for-build');
+
+const PROCESSING_STATUSES = ['pending', 'processing', 'queued', 'deploying'];
+
+export const WAIT_FOR_BUILD_FINISH_STEP = {
+  message: 'Wait till the app will process to draft status...',
+  /**
+   * @param {object} param0
+   * @param {import('../../lib/api').Api} param0.api
+   */
+  async fn({ api, appId, packageId, progress }) {
+    do {
+      const { status, notes } = await api.checkApp(appId, packageId);
+
+      progress();
+
+      debug(`Status: ${status}`);
+
+      if (!PROCESSING_STATUSES.includes(status)) {
+        if (notes) {
+          logger.write('\nNotes after package upload:\n\n');
+          logger.write(notes);
+        }
+
+        return { uploadStatus: status };
+      }
+
+      await waitForMs(5000);
+      // eslint-disable-next-line no-constant-condition
+    } while (true);
+  },
+};

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

@@ -0,0 +1,77 @@
+import chalk from 'chalk';
+
+import { logger } from '../../../helpers/logger.js';
+
+export const CREATE_TASK_STEP = {
+  message: 'Creating tasks...',
+  /**
+   *
+   * @param {object} param0
+   * @param {import('../../lib/api').Api} param0.api
+   */
+  fn: async ({
+    app,
+    assets,
+    appDatasetsNames,
+    mappedAssetsToStreams,
+    mappedAssetsToWells,
+    api,
+    version,
+    interval,
+    corvaUrl,
+    options,
+  }) => {
+    const { cache } = options;
+
+    if (!assets.length) {
+      logger.write(`\n\n${chalk.yellow.bold('There is no asset ID to create a new task')}`);
+    }
+
+    logger.write(`\n    ${corvaUrl}/dev-center/apps/${app.id}/runner`);
+
+    let i = 1;
+
+    for (const assetId of assets) {
+      const wellId = mappedAssetsToWells.get(parseInt(assetId)).id;
+      const stream = mappedAssetsToStreams.get(parseInt(assetId));
+      const streamId = stream.id;
+      const connectedApps = stream.app_connections.filter((connectedApp) => connectedApp.app_id === Number(app.id));
+
+      if (!wellId || !streamId) {
+        logger.write(
+          `\n\n${chalk.red.underline.bold(
+            `Skipped creating a task for asset ID - ${assetId}, well ID or stream ID is missing`,
+          )}\n\n`,
+        );
+
+        continue;
+      }
+
+      try {
+        for (const connectedApp of connectedApps) {
+          const extraNotification = connectedApps.length > 1 ? `(connected app ID ${connectedApp.id})` : '';
+          const result = await api
+            .queueAppRun(app.id, version, interval, wellId, appDatasetsNames, stream.id, connectedApp.id, cache)
+            .catch((e) => {
+              console.log(e.response.body);
+
+              throw e;
+            });
+
+          logger.write(`
+            \n${i}/${assets.length}. Re-run ID ${chalk.yellow(
+            result.id,
+          )} for the asset - ${corvaUrl}/assets/${assetId} ${extraNotification}`);
+        }
+
+        i++;
+      } catch (e) {
+        logger.write(
+          `\n\n${chalk.red.underline.bold(
+            `Could not rerun app for asset ID - ${assetId}, an error occurred: ${e.message}`,
+          )}\n\n`,
+        );
+      }
+    }
+  },
+};

package/lib/flows/steps/rerun/ensure-that-app-in-stream.js

@@ -0,0 +1,68 @@
+import chalk from 'chalk';
+
+import { logger } from '../../../helpers/logger.js';
+
+export const ENSURE_APP_IN_STREAM_TASK_STEP = {
+  message: 'Ensure that app in the stream...',
+  /**
+   *
+   * @param {object} context
+   */
+  fn: async (context) => {
+    const { mappedAssetsToStreams, app, api, manifest, corvaUrl } = context;
+
+    await Promise.all(
+      [...mappedAssetsToStreams].map(([assetId, stream]) => {
+        return ensureAppIsInTheStream(assetId, stream, app.id, api, manifest, corvaUrl);
+      }),
+    );
+
+    return context;
+  },
+};
+
+/**
+ *  Ensure if the app is in the stream, if no, add app to the stream
+ *
+ * @param {string} assetId
+ * @param {object} stream
+ * @param {string} appId
+ * @param {import('../lib/api').Api} api
+ * @param {object} manifest
+ * @param {string} corvaUrl
+ *
+ * @returns {void}
+ */
+const ensureAppIsInTheStream = async (assetId, stream, appId, api, manifest, corvaUrl) => {
+  const connectedApps = stream.app_connections.filter((connection) => connection.app_id === parseInt(appId));
+
+  if (connectedApps.length) {
+    if (connectedApps.length > 1) {
+      logger.write(
+        `\n\n${chalk.black.underline.bold(
+          `Attention, this app connected to the stream more than once: ${corvaUrl}/config/streams/${stream.id}, Asset ID: ${assetId}. Logic will make a rerun per each app`,
+        )}`,
+      );
+
+      return;
+    }
+
+    logger.write(
+      `\n\n${chalk.black.underline.bold(
+        `App has been already connected to the stream: ${corvaUrl}/config/streams/${stream.id}, Asset ID: ${assetId}`,
+      )}`,
+    );
+
+    return;
+  }
+
+  const newConnection = await api.connectAppToStream(appId, stream.id, manifest.manifest.settings.app);
+
+  stream.app_connections.push(newConnection);
+
+  logger.write(
+    `\n\n${chalk.black.underline.bold(
+      `Added app to the stream: ${corvaUrl}/config/streams/${stream.id} App: ${corvaUrl}/config/streams/${stream.id}/apps/${newConnection.id}, Asset ID: ${assetId}`,
+    )}`,
+  );
+};