@corva/create-app 0.0.0-2576df8

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}`,
+    )}`,
+  );
+};

package/lib/flows/steps/rerun/get-app-version.js

@@ -0,0 +1,111 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+import { logger } from '../../../helpers/logger.js';
+import { StepError } from '../../lib/step-error.js';
+
+export const GET_APP_VERSION_TASK_STEP = {
+  message: 'Get app version...',
+  /**
+   *
+   * @param {object} context
+   */
+  fn: async (context) => {
+    const { app, options, api } = context;
+    const { appVersion } = options;
+
+    const currentAppVersion = await getAppVersion(app.id, appVersion, api);
+
+    return {
+      ...context,
+      version: currentAppVersion,
+    };
+  },
+};
+
+/**
+ *  CLI prompt question - Please choose the app version (optional).
+ *
+ * @param {string} appId
+ * @param {string} optionAppVersion
+ * @param {import('../lib/api').Api} api
+ *
+ * @returns {Promise<{number}>}
+ */
+const getAppVersion = async (appId, optionAppVersion, api) => {
+  logger.write('\n    Checking app versions...');
+
+  const appPackages = await api.getAppPackages(appId);
+
+  if (!appPackages.length) {
+    throw new StepError('No app versions found');
+  }
+
+  const confirmUseVersionMessage = (version) => {
+    logger.write(`\n\n${chalk.black.underline.bold(`Use app version - ${chalk.green(version)}`)}`);
+  };
+
+  // try to get version from CLI option
+  if (optionAppVersion) {
+    const currentAppPackageByOption = appPackages.find(
+      (appPackage) => appPackage.attributes.version === optionAppVersion,
+    );
+
+    if (currentAppPackageByOption) {
+      const version = currentAppPackageByOption.attributes.version;
+
+      confirmUseVersionMessage(version);
+
+      return version;
+    }
+
+    logger.write(`\n\n${chalk.black.underline.bold(`Could not find app version - ${chalk.green(optionAppVersion)}`)}`);
+  }
+
+  // if there is only on version, use it.
+  if (appPackages.length === 1) {
+    const version = appPackages[0].attributes.version;
+
+    confirmUseVersionMessage(version);
+
+    return version;
+  }
+
+  // if there are several versions, show versions list to user
+  const choices = appPackages.map((appPackage) => {
+    const parts = [];
+    const { notes, label, version } = appPackage.attributes;
+
+    if (label) {
+      parts.push(label);
+    }
+
+    if (notes) {
+      parts.push(notes);
+    }
+
+    if (version) {
+      parts.push(version);
+    }
+
+    return {
+      value: appPackage.attributes.version,
+      name: parts.join(' '),
+    };
+  });
+
+  logger.log('\n');
+
+  return inquirer
+    .prompt([
+      {
+        message: 'Please choose the app version?',
+        name: 'option',
+        type: 'list',
+        choices,
+      },
+    ])
+    .then((answers) => {
+      return answers.option;
+    });
+};

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

@@ -0,0 +1,162 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import _ from 'lodash';
+import { logger } from '../../../helpers/logger.js';
+import { StepError } from '../../lib/step-error.js';
+
+const MAX_ASSET_IDS_COUNT = 300;
+
+export const PREPARE_DATA_TASK_STEP = {
+  message: 'Preparing and checking data...',
+  fn: async (context) => {
+    const { manifest, options, api, CORVA_API_ENV } = context;
+    let { assets, interval, companyId } = options;
+
+    if (companyId) {
+      assets = await getAssetsByCompanyId(companyId, api);
+    }
+
+    assets = _.uniq(assets);
+
+    if (assets.length > MAX_ASSET_IDS_COUNT) {
+      throw new StepError(`Please no more than ${MAX_ASSET_IDS_COUNT} asset ids!`);
+    }
+
+    if (!['scheduler', 'stream'].includes(manifest.manifest.application.type)) {
+      throw new StepError('Rerun command supports only "scheduler" or "stream" apps');
+    }
+
+    if (!(await promptAreYouSure())) {
+      throw new StepError('Command stopped');
+    }
+
+    const app = await api.getAppByKey(manifest.manifest.application.key);
+    const appDatasets = await api.getAppDatasetsOperationWrite(app.id);
+    const appDatasetsNames = appDatasets.map((dataset) => dataset.attributes.dataset_name);
+
+    const existingAppRuns = await getExistAppRuns(app.id, assets, appDatasetsNames, api);
+
+    if (existingAppRuns.size) {
+      for (const appRunAssetId of existingAppRuns.keys()) {
+        // remove asset ID if similar rerun already exists
+        assets = assets.filter((assetId) => appRunAssetId !== assetId);
+
+        const run = existingAppRuns.get(appRunAssetId);
+
+        logger.write(
+          `\n\n${chalk.yellow.bold(
+            `A similar rerun with ID ${run.id}, for asset ID ${appRunAssetId} - already exists. Will be skipped!`,
+          )}`,
+        );
+      }
+    }
+
+    const corvaUrl = `https://app${CORVA_API_ENV === 'production' ? '.' : `.${CORVA_API_ENV}.`}corva.ai`;
+
+    return {
+      assets,
+      corvaUrl,
+      app,
+      options,
+      manifest,
+      appDatasetsNames,
+      interval: getInterval(manifest.manifest, interval),
+    };
+  },
+};
+
+/**
+ *  CLI prompt question - Are you sure you want to do this?
+ *
+ * @returns
+ */
+const promptAreYouSure = async () => {
+  logger.log('\n');
+
+  const answers = await inquirer.prompt([
+    {
+      message:
+        'This command will create an additional load on the server, which may take a long time. \n Are you sure you want to do this?',
+      name: 'option',
+      type: 'list',
+      choices: [
+        { value: true, name: 'Yes' },
+        { value: false, name: 'No' },
+      ],
+      default: false,
+    },
+  ]);
+
+  return answers.option;
+};
+
+/**
+ *  Get all suitable assets for rerun by company ID
+ *
+ * @param {number} comanyId
+ * @param {object} api
+ *
+ * @returns {number[]}
+ */
+const getAssetsByCompanyId = async (companyId, api) => {
+  logger.write('\n    Try to find all suitable assets by Company ID...');
+
+  const assets = await api.getAllAssets(['complete', 'idle', 'paused', 'unknown'], companyId);
+
+  logger.write(`\n\n Found ${chalk.yellow.bold(assets.length)} assets, for the company ID ${companyId}!`);
+
+  return assets.map((asset) => asset.id);
+};
+
+/**
+ *  Check if current runs already exist
+ *
+ * @param {string} appId
+ * @param {string[]} assets
+ * @param {string[]} appDatasetsNames
+ * @param {object} api
+ *
+ * @returns {map}
+ */
+const getExistAppRuns = async (appId, assets, appDatasetsNames, api) => {
+  const appRuns = new Map();
+  const existingAppRuns = await api.getAppRuns(appId);
+
+  // go through all assets ids
+  for (const assetId of assets) {
+    const runsForCurrentAsset = existingAppRuns.filter((run) => run.attributes.well_asset_id === assetId);
+
+    // go through all existing runs for current asset ID
+    for (const run of runsForCurrentAsset) {
+      const currentAppDatasetsNames = run.attributes.app_run_datasets.map((dataset) => dataset.name);
+
+      // if datasets names matched for the same asset ID - then run already exist
+      if (appDatasetsNames.sort().toString() === currentAppDatasetsNames.sort().toString()) {
+        appRuns.set(assetId, run);
+      }
+    }
+  }
+
+  return appRuns;
+};
+
+/**
+ *  Get interval
+ *
+ * @param {object} manifest
+ * @param {number} intervalOption
+ *
+ * @returns {number | null}
+ */
+const getInterval = (manifest, intervalOption) => {
+  if (manifest.application.type !== 'scheduler') {
+    return null;
+  }
+
+  const DEFAULT_INTERVAL = 3600;
+  const interval = intervalOption || DEFAULT_INTERVAL;
+
+  logger.write(`\n\n${chalk.black.underline.bold(`Use interval - ${chalk.green(interval)}`)}`);
+
+  return parseInt(interval);
+};

package/lib/flows/steps/rerun/prepare-well-and-stream-data.js

@@ -0,0 +1,188 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+import { logger } from '../../../helpers/logger.js';
+
+export const PREPARE_WELL_AND_STREAM_TASK_STEP = {
+  message: 'Prepare well and stream data...',
+  /**
+   *
+   * @param {object} context
+   */
+  fn: async (context) => {
+    let { assets } = context;
+    const {
+      api,
+      manifest,
+      options: { forceStreamLogType },
+    } = context;
+
+    const { mappedAssetsToWells, mappedAssetsToStreams, assetsToDelete } = await prepareWellAndStreamData(
+      assets,
+      api,
+      manifest,
+      forceStreamLogType,
+    );
+
+    if (assetsToDelete.length) {
+      // remove asset ID if could not found stream or well
+      assets = assets.filter((assetId) => !assetsToDelete.includes(assetId));
+    }
+
+    return {
+      ...context,
+      assets,
+      mappedAssetsToStreams,
+      mappedAssetsToWells,
+    };
+  },
+};
+
+/**
+ *  CLI prompt question - Please choose the stream
+ *
+ * @param {object[]} streams
+ * @param {('time'|'depth')} [forceStreamLogType]
+ *
+ * @returns {Promise<object>}
+ */
+const getStreamWithPrompt = async (streams, forceStreamLogType) => {
+  const _streams = forceStreamLogType ? streams.filter((stream) => stream.log_type === forceStreamLogType) : streams;
+
+  const choices = _streams.map((stream) => {
+    return {
+      value: stream,
+      name: `${stream.name} (${stream.log_type})`,
+    };
+  });
+
+  if (!choices.length) {
+    throw new Error('No completed streams');
+  }
+
+  if (choices.length === 1) {
+    const [stream] = choices;
+
+    logger.write(`\n\n${chalk.black.underline.bold(`Process stream - ${chalk.green(stream.name)}`)}`);
+
+    return stream.value;
+  }
+
+  logger.log('\n');
+
+  return inquirer
+    .prompt([
+      {
+        message: 'Please choose stream?',
+        name: 'option',
+        type: 'list',
+        choices,
+      },
+    ])
+    .then((answers) => answers.option);
+};
+
+/**
+ *  CLI prompt question - Please choose the well
+ *
+ * @param {object[]} wells
+ * @param {import('../lib/api').Api} api
+ *
+ * @returns {Promise<object>}
+ */
+const getWellWithPrompt = async (wells, api) => {
+  const choices = await Promise.all(
+    wells.map(async (well) => {
+      const assetDetails = await api.getAssetById(well.data.attributes.asset_id);
+
+      well.data.name = assetDetails.attributes.name;
+
+      return {
+        value: well.data,
+        name: well.data.name,
+      };
+    }),
+  );
+
+  if (!choices.length) {
+    throw new Error('No wells found');
+  }
+
+  if (choices.length === 1) {
+    const [well] = choices;
+
+    logger.write(`\n\n${chalk.black.underline.bold(`Process well - ${chalk.green(well.name)}`)}`);
+
+    return well.value;
+  }
+
+  logger.log('\n');
+
+  return inquirer
+    .prompt([
+      {
+        message: 'Please choose the well?',
+        name: 'option',
+        type: 'list',
+        choices,
+      },
+    ])
+    .then((answers) => answers.option);
+};
+
+/**
+ *  Get stream and well data for assets
+ *
+ * @param {string[]} assets
+ * @param {import('../lib/api').Api} api
+ * @param {object} manifest
+ * @param {('time'|'depth')} [forceStreamLogType]
+ *
+ * @returns {Promise<object>}
+ */
+const prepareWellAndStreamData = async (assets, api, manifest, forceStreamLogType) => {
+  const mappedAssetsToWells = new Map();
+  const mappedAssetsToStreams = new Map();
+  const assetsToDelete = [];
+
+  for (const assetId of assets) {
+    try {
+      logger.write(`\n\n${chalk.black.underline.bold(`Process asset ID - ${chalk.green(assetId)}`)}`);
+
+      logger.write('\n    Loading wells...');
+
+      const wells = await api.getWellByAssetId(assetId);
+      const well = await getWellWithPrompt(wells, api);
+
+      mappedAssetsToWells.set(well.attributes.asset_id, well);
+
+      logger.write('\n    Loading streams...');
+
+      const streams = await api.getStreamsByAssetIds([assetId], manifest.manifest.application.segments);
+
+      if (!streams || !streams.length) {
+        throw new Error(`Could not found streams in Complete status for the asset ID - ${assetId}`);
+      }
+
+      const stream = await getStreamWithPrompt(streams, forceStreamLogType);
+
+      mappedAssetsToStreams.set(stream.asset_id, stream);
+    } catch (e) {
+      logger.write(
+        `\n\n${chalk.red.underline.bold(`Skipped the asset ID - ${assetId}, an error occurred: ${e.message}`)}`,
+      );
+
+      assetsToDelete.push(assetId);
+
+      if (mappedAssetsToWells.has(assetId)) mappedAssetsToWells.delete(assetId);
+
+      if (mappedAssetsToStreams.has(assetId)) mappedAssetsToStreams.delete(assetId);
+    }
+  }
+
+  return {
+    mappedAssetsToWells,
+    mappedAssetsToStreams,
+    assetsToDelete,
+  };
+};

package/lib/flows/steps/rerun/rerun.js

@@ -0,0 +1,13 @@
+import { CREATE_TASK_STEP } from './create-task.js';
+import { PREPARE_DATA_TASK_STEP } from './prepare-data.js';
+import { GET_APP_VERSION_TASK_STEP } from './get-app-version.js';
+import { ENSURE_APP_IN_STREAM_TASK_STEP } from './ensure-that-app-in-stream.js';
+import { PREPARE_WELL_AND_STREAM_TASK_STEP } from './prepare-well-and-stream-data.js';
+
+export const RERUN_STEPS = [
+  PREPARE_DATA_TASK_STEP,
+  GET_APP_VERSION_TASK_STEP,
+  PREPARE_WELL_AND_STREAM_TASK_STEP,
+  ENSURE_APP_IN_STREAM_TASK_STEP,
+  CREATE_TASK_STEP,
+];

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

@@ -0,0 +1,17 @@
+import { promises as fs } from 'node:fs';
+import { resolve } from 'node:path';
+
+import debugFn from 'debug';
+
+const debug = debugFn('cca:flow:zip:cleanup');
+
+export 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));
+    }
+  },
+};

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

@@ -0,0 +1,15 @@
+import debugFn from 'debug';
+import { createZipArchive } from '../lib/create-zip-archive.js';
+
+const debug = debugFn('cca:flow:zip:archive');
+
+export 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);
+  },
+};