@corva/create-app 0.41.0-2 → 0.42.0-0

package/lib/flows/lib/api.js

@@ -42,11 +42,12 @@ export class Api {
    * @returns  {object}
    */
   async getAppByKey(appKey) {
-    const { data: [app] } = await this.#api.get('v2/apps', {
+    const { data } = await this.#api.get('v2/apps', {
       searchParams: { per_page: 2, search: appKey }
     }).json();
 
-    if (!app || app.attributes.app_key != appKey) {
+    const app = data.find(app => app.attributes.app_key === appKey);
+    if (!app) {
       throw new Error(`App with key - ${appKey}, not exist`);
     }
 
@@ -64,11 +65,6 @@ export class Api {
    */
   async getAppDatasetsOperationWrite(appId) {
     const { data } = await this.#api.get(`v2/apps/${appId}/app_datasets?dataset_operation=write&fields[]=app_dataset.dataset_name`).json();
-
-    if (!data.length) {
-      throw new Error(`App with ID - ${appId}, has no datasets`);
-    }
-
     return data;
   }
 
@@ -138,13 +134,14 @@ export class Api {
    *
    * @param {string} appId
    * @param {string} version
+   * @param {number} interval
    * @param {string} wellId
    * @param {string[]} appDatasetsNames
    * @param {string} streamId
    *
    * @returns  {object}
    */
-  async queueAppRun(appId, version, wellId, appDatasetsNames, streamId) {
+  async queueAppRun(appId, version, interval, wellId, appDatasetsNames, streamId) {
     const json = {
       app_run: {
         app_stream_id: streamId,
@@ -153,7 +150,6 @@ export class Api {
         datasets: appDatasetsNames,
         settings: {
           end: 0,
-          interval: null,
           invokes: null,
           records_per_event: 300,
           start: 0,
@@ -161,6 +157,10 @@ export class Api {
       },
     };
 
+    if (interval) {
+      json.app_run.settings.interval = interval;
+    }
+
     const { data } = await this.#api.post(`v2/apps/${appId}/app_runs`, { json }).json();
 
     return data;
@@ -279,6 +279,42 @@ export class Api {
     };
   }
 
+ /**
+ * Get app packages
+ * 
+ * @param {string} appId
+ *
+ * @returns { Promise<object[]>}
+ */
+  async getAppPackages(appId) {
+    const { data } = await this.#api.get(`v2/apps/${appId}/packages`).json();
+    return data;
+  }
+
+  /**
+   * Connect app to the stream
+   *
+   * @public
+   *
+   * @param {string} appId
+   * @param {string} streamId
+   * @param {object} settings
+   * @param {string} status
+   *
+   * @returns  { Promise<object> }
+   */
+   async connectAppToStream(appId, streamId, settings, status='active') {
+    const json = {
+      app_stream_id: streamId,
+      app_id: appId,
+      status,
+      settings: settings,
+      scheduler_type: settings.scheduler_type
+    };
+
+    return this.#api.post('v1/app_connections', { json }).json();
+  }
+
   /**
  * @param {string} appId
  * @param {string} id

package/lib/flows/rerun.js

@@ -1,5 +1,5 @@
 import { PREPARE_FLOW } from './prepare.js';
-import { RERUN_STEPS } from './steps/rerun.js';
+import { RERUN_STEPS } from './steps/rerun/rerun.js';
 import { SETUP_API_CLIENT_STEP } from './steps/release/get-config.js';
 
 export const RERUN_FLOW = {

package/lib/flows/steps/{rerun-create-task.js → rerun/create-task.js}

@@ -1,55 +1,69 @@
 import _ from 'lodash';
 import chalk from 'chalk';
 
-import { logger } from '../../helpers/logger.js';
+import { logger } from '../../../helpers/logger.js';
 
 export const CREATE_TASK_STEP = {
   message: 'Creating tasks...',
   /**
    * 
    * @param {object} param0 
-   * @param {import('../lib/api').Api} param0.api 
+   * @param {import('../../lib/api').Api} param0.api 
    */
   fn: async ({
-    appId,
+    app,
     assets,
     appDatasetsNames,
     mappedAssetsToStreams,
     mappedAssetsToWells,
     api,
     version,
+    interval,
     CORVA_API_ENV,
   }) => {
     if (!assets.length) {
       logger.write(
-        `\n\n${chalk.yellow.bold('There is not a asset ID to create new task')}`
+        `\n\n${chalk.yellow.bold('There is no asset ID to create a new task')}`
       );
     }
 
     for (const assetId of assets) {
+      const wellId = mappedAssetsToWells.get(parseInt(assetId)).id;
+      const streamId = mappedAssetsToStreams.get(parseInt(assetId)).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 {
         const result = await api.queueAppRun(
-          appId,
+          app.id,
           version,
-          assetId,
+          interval,
+          wellId,
           appDatasetsNames,
-          mappedAssetsToStreams.get(parseInt(assetId))
+          streamId,
         ).catch(e => { console.log(e.response.body); throw e });
 
         logger.write(
-          `\n    Created new task with ID ${chalk.yellow(result.id)} for asset ID - ${chalk.green(
+          `\n    Created a new task with ID ${chalk.yellow(result.id)} for asset ID - ${chalk.green(
             assetId
           )}`
         );
 
         logger.write(
           `\n    Task link - https://app${CORVA_API_ENV === 'production' ? '.' : `.${CORVA_API_ENV}.`
-          }corva.ai/dev-center/apps/${appId}/runner`
+          }corva.ai/dev-center/apps/${app.id}/runner`
         );
       } catch (e) {
         logger.write(
           `\n\n${chalk.red.underline.bold(
-            `Could not rerun app for asset ID - ${assetId}, an error occured: ${e.message}`
+            `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,51 @@
+import _ from 'lodash';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+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 } = context;
+
+    await Promise.all(
+      [...mappedAssetsToStreams].map(([assetId, stream]) => {
+        return ensureAppIsInTheStream(assetId, stream, app.id, api, manifest);
+      })
+    );
+
+    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
+  *
+  * @returns {void}
+  */
+  const ensureAppIsInTheStream = async (assetId, stream, appId, api, manifest) => {
+    const connectedApp = stream.app_connections.find((connection) => connection.app_id == appId);
+    if (connectedApp) {
+      logger.write(
+        `\n\n${chalk.black.underline.bold(`App has already connected to the stream ID: ${stream.id}, for asset ID: ${assetId}`)}`
+      );
+      return;
+    }
+
+    const newConnection = await api.connectAppToStream(appId, stream.id, manifest.settings.app);
+
+    logger.write(
+      `\n\n${chalk.black.underline.bold(`Added app to the stream, connect ID - ${chalk.green(newConnection.id)}, for asset ID: ${assetId}`)}`
+    );
+  }

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

@@ -0,0 +1,92 @@
+import _ from 'lodash';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+import { logger } from '../../../helpers/logger.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 Error('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) => {
+    return {
+      value: appPackage.attributes.version,
+      name: appPackage.attributes.version,
+    };
+  })
+
+  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,138 @@
+import _ from 'lodash';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { StepError } from '../../lib/step-error.js';
+import { logger } from '../../../helpers/logger.js';
+
+const MAX_ASSET_IDS_COUNT = 10;
+
+export const PREPARE_DATA_TASK_STEP = {
+  message: 'Preparing and checking data...',
+  fn: async (context) => {
+    const { manifest, options, api } = context;
+    let { assets, interval } = options;
+
+    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.toLowerCase());
+    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 (let 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!`
+          )}`
+        );
+      }
+    }
+
+    return {
+      assets,
+      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;
+};
+
+/**
+ *  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,182 @@
+import _ from 'lodash';
+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 } = context;
+
+    const { mappedAssetsToWells, mappedAssetsToStreams, assetsToDelete } =
+      await prepareWellAndStreamData(assets, api);
+
+    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
+ *
+ * @returns
+ */
+ const getStreamWithPrompt = async (streams) => {
+  let stream = {};
+
+  const choices = streams.map((stream) => {
+    return {
+      value: stream,
+      name: stream.name,
+    };
+  });
+
+  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')
+
+  await inquirer
+    .prompt([
+      {
+        message: 'Please choose stream?',
+        name: 'option',
+        type: 'list',
+        choices,
+      },
+    ])
+    .then((answers) => {
+      stream = answers.option;
+    });
+
+  return stream;
+};
+
+/**
+ *  CLI prompt question - Please choose the well
+ *
+ * @param {object[]} wells
+ * @param {import('../lib/api').Api} api
+ *
+ * @returns
+ */
+const getWellWithPrompt = async (wells, api) => {
+  let well = {};
+
+  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')
+
+  await inquirer
+    .prompt([
+      {
+        message: 'Please choose the well?',
+        name: 'option',
+        type: 'list',
+        choices,
+      },
+    ])
+    .then((answers) => {
+      well = answers.option;
+    });
+
+  return well;
+};
+
+/**
+ *  Get stream and well data for assets
+ *
+ * @param {string[]} assets
+ * @param {string} appId
+ * @param {import('../lib/api').Api} api
+ * @param {object} manifest
+ *
+ * @returns {object}
+ */
+const prepareWellAndStreamData = async (assets, api) => {
+  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.getStreamByAssetId(assetId);
+      const stream = await getStreamWithPrompt(streams);
+      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/main.js

@@ -200,6 +200,8 @@ export async function run() {
     .addOption(envOption)
     .addOption(silentOption)
     .addOption(new Option('--assets [assets...]', 'Assets ids list', []))
+    .addOption(new Option('--app-version [number]', 'App version (exp. 1, 2, 3)'))
+    .addOption(new Option('--interval [number]', 'Interval for scheduler apps (exp. 1200)'))
     .action(async (dirName, options) => {
       await runFlow(RERUN_FLOW, { dirName, options });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@corva/create-app",
-    "version": "0.41.0-2",
+    "version": "0.42.0-0",
     "private": false,
     "description": "Create app to use it in CORVA.AI",
     "keywords": [

package/templates/javascript/ui/README.md

@@ -26,6 +26,6 @@ Releases the app into Corva
 
 ## Documentation
 
-- [Dev Center documentation](https://app.corva.ai/dev-center/docs/frontend) – information about development process
-- [Component Library](https://app.corva.ai/dev-center/docs/frontend/storybook)
-- [Datasets documentation](https://app.corva.ai/dev-center/docs/datasets)
+- [Dev Center documentation](https://dc-docs.corva.ai/) – information about development process
+- [Component Library](https://dc-docs.corva.ai/docs/Frontend/Data%20visualization/Components%20library)
+- [Datasets documentation](https://dc-docs.corva.ai/docs/Datasets/Link%20App%20to%20Dataset)

package/templates/typescript/ui/README.md

@@ -26,6 +26,6 @@ Releases the app into Corva
 
 ## Documentation
 
-- [Dev Center documentation](https://app.corva.ai/dev-center/docs/frontend) – information about development process
-- [Component Library](https://app.corva.ai/dev-center/docs/frontend/storybook)
-- [Datasets documentation](https://app.corva.ai/dev-center/docs/datasets)
+- [Dev Center documentation](https://dc-docs.corva.ai/) – information about development process
+- [Component Library](https://dc-docs.corva.ai/docs/Frontend/Data%20visualization/Components%20library)
+- [Datasets documentation](https://dc-docs.corva.ai/docs/Datasets/Link%20App%20to%20Dataset)

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

@@ -1,266 +0,0 @@
-import _ from 'lodash';
-import chalk from 'chalk';
-import inquirer from 'inquirer';
-import { StepError } from '../lib/step-error.js';
-import { logger } from '../../helpers/logger.js';
-
-const MAX_ASSET_IDS_COUNT = 10;
-
-export const PREPARE_DATA_STEP = {
-  message: 'Preparing data for tasks...',
-  fn: async (context) => {
-    const { manifest, options, api, pkg } = context;
-    let { assets } = options;
-
-    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.toLowerCase());
-    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 (let 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(
-            `Similar rerun with ID ${run.id}, for asset ID ${appRunAssetId} - already exist. Will be skipped!`
-          )}`
-        );
-      }
-    }
-
-    const { mappedAssetsToWells, mappedAssetsToStreams, assetsToDelete } =
-      await prepareWellAndStreamData(assets, api);
-
-    if (assetsToDelete.length) {
-      // remove asset ID if could not found stream or well
-      assets = assets.filter((assetId) => !assetsToDelete.includes(assetId));
-    }
-
-    return {
-      appId: app.id,
-      assets,
-      appDatasetsNames,
-      mappedAssetsToStreams,
-      mappedAssetsToWells,
-      version: pkg.version,
-    };
-  },
-};
-
-/**
- *  CLI prompt question - Are you sure you want to do this?
- *
- * @returns
- */
-const promptAreYouSure = async () => {
-  const answers = await inquirer.prompt([
-    {
-      message:
-        '\n This command will create 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;
-};
-
-/**
- *  CLI prompt question - Please choose the stream
- *
- * @param {object[]} streams
- *
- * @returns
- */
-const getStreamWithPrompt = async (streams) => {
-  let stream = {};
-
-  const choices = streams.map((stream) => {
-    return {
-      value: stream,
-      name: stream.name,
-    };
-  });
-
-  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
-  }
-
-  await inquirer
-    .prompt([
-      {
-        message: '\n Please choose stream?',
-        name: 'option',
-        type: 'list',
-        choices,
-      },
-    ])
-    .then((answers) => {
-      stream = answers.option;
-    });
-
-  return stream;
-};
-
-/**
- *  CLI prompt question - Please choose the well
- *
- * @param {object[]} wells
- * @param {import('../lib/api').Api} api
- *
- * @returns
- */
-const getWellWithPrompt = async (wells, api) => {
-  let well = {};
-
-  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
-  }
-
-  await inquirer
-    .prompt([
-      {
-        message: '\n Please choose the well?',
-        name: 'option',
-        type: 'list',
-        choices,
-      },
-    ])
-    .then((answers) => {
-      well = answers.option;
-    });
-
-  return well;
-};
-
-/**
- *  Get stream and well data for assets
- *
- * @param {string[]} assets
- * @param {import('../lib/api').Api} api
- *
- * @returns {object}
- */
-const prepareWellAndStreamData = async (assets, api) => {
-  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.id);
-
-      logger.write('\n    Loading streams...');
-
-      const streams = await api.getStreamByAssetId(assetId);
-      const stream = await getStreamWithPrompt(streams);
-      mappedAssetsToStreams.set(stream.asset_id, stream.id);
-    } catch (e) {
-      logger.write(
-        `\n\n${chalk.red.underline.bold(
-          `Skipped the asset ID - ${assetId}, an error occured: ${e.message}`
-        )}`
-      );
-
-      assetsToDelete.push(assetId);
-
-      if (mappedAssetsToWells.has(assetId)) mappedAssetsToWells.delete(assetId);
-      if (mappedAssetsToStreams.has(assetId)) mappedAssetsToStreams.delete(assetId);
-    }
-  }
-
-  return { mappedAssetsToWells, mappedAssetsToStreams, assetsToDelete };
-};
-
-/**
- *  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;
-};

package/lib/flows/steps/rerun.js

@@ -1,4 +0,0 @@
-import { PREPARE_DATA_STEP } from './rerun-prepare-data.js';
-import { CREATE_TASK_STEP } from './rerun-create-task.js';
-
-export const RERUN_STEPS = [PREPARE_DATA_STEP, CREATE_TASK_STEP];