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

package/README.md

@@ -27,6 +27,7 @@ Commands:
   zip [options] <project-directory> [patterns...]      Bundle app
   release [options] <project-directory> [patterns...]  Release app
   rerun [options] <project-directory>                  Rerun app
+  attach [options] <project-directory>                 Add app to live assets streams
   help [command]                                       display help for command
 ```
 
@@ -176,6 +177,7 @@ Options:
   --label [string]             Put a label on the release (choices: "BETA", "STABLE")
   --remove-on-fail [boolean]   Remove release if it fails during deployment (default: false)
   --silent [boolean]           Only log result of the operation (default: false)
+  --remove-on-success          App package (.zip) will not be deleted after upload (default: true)
 ```
 
 ### Examples

package/lib/bump-version.option.js

@@ -21,19 +21,26 @@ export const bumpVersionOption = new Option(flags, description)
   .choices(choices)
   .argParser(argParser);
 
-export const apiKeyOption = new Option('--api-key [string]',
-  'Pre generated API key for authorization during app upload')
+export const apiKeyOption = new Option(
+  '--api-key [string]',
+  'Pre generated API key for authorization during app upload'
+);
+
+export const appVersion = new Option('--app-version [number]', 'App version (exp. 1, 2, 3)');
 
 export const envOption = new Option('--env [string]', 'Environment to use')
   .choices(['qa', 'staging', 'production'])
-  .default('qa')
+  .default('qa');
 
-export const silentOption = new Option('--silent [boolean]', 'Only log result of the operation').default(false)
+export const silentOption = new Option(
+  '--silent [boolean]',
+  'Only log result of the operation'
+).default(false);
 
 export const bumpVersionOptionDeprecated = new Option(
   flags,
   chalk.bgYellow`DEPRECATED` +
-  ` Use with ${chalk.cyan`zip`} or ${chalk.cyan`release`} command instead`
+    ` Use with ${chalk.cyan`zip`} or ${chalk.cyan`release`} command instead`
 )
   .choices(choices)
   .argParser(argParser);

package/lib/flow.js

@@ -14,7 +14,7 @@ export const runFlow = async (flow, context, indent = '') => {
     )}\n`
   );
 
-  context.progress = () => logger.write('.')
+  context.progress = () => logger.write('.');
 
   const result = await runSteps(flow.steps, context, indent + '  ');
 

package/lib/flows/attach.js

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

package/lib/flows/lib/api.js

@@ -1,7 +1,6 @@
 import got from 'got';
 import Debug from 'debug';
 import { StepError } from './step-error.js';
-import _ from 'lodash/fp.js';
 
 const debug = Debug('cca:api');
 
@@ -11,8 +10,8 @@ const debug = Debug('cca:api');
  */
 export class Api {
   /**
-    * @type {import('got').Got}
-    */
+   * @type {import('got').Got}
+   */
   #api;
 
   constructor(envName, apiKey, authToken = null) {
@@ -27,9 +26,9 @@ export class Api {
         'Accept': 'application/json',
       },
       hooks: {
-        beforeRequest: [debug]
-      }
-    })
+        beforeRequest: [debug],
+      },
+    });
   }
 
   /**
@@ -42,11 +41,13 @@ export class Api {
    * @returns  {object}
    */
   async getAppByKey(appKey) {
-    const { data } = await this.#api.get('v2/apps', {
-      searchParams: { per_page: 2, search: appKey }
-    }).json();
+    const { data } = await this.#api
+      .get('v2/apps', {
+        searchParams: { per_page: 2, search: appKey },
+      })
+      .json();
 
-    const app = data.find(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,7 +65,11 @@ export class Api {
    * @returns  {object}
    */
   async getAppDatasetsOperationWrite(appId) {
-    const { data } = await this.#api.get(`v2/apps/${appId}/app_datasets?dataset_operation=write&fields[]=app_dataset.dataset_name`).json();
+    const { data } = await this.#api
+      .get(
+        `v2/apps/${appId}/app_datasets?dataset_operation=write&fields[]=app_dataset.dataset_name`
+      )
+      .json();
     return data;
   }
 
@@ -84,27 +89,42 @@ export class Api {
   }
 
   /**
-   * Get asset streams
+   * Get assets streams by ids
    *
    * @public
    *
-   * @param {string} assetId
+   * @param {string[]} assetIds
+   * @param {string[]} segments
+   * @param {string[]} statuses
    *
-   * @returns  {object[]}
+   * @returns  {Promise<object[]>}
    */
-  async getStreamByAssetId(assetId) {
-    const data = await this.#api.get(`v1/app_streams`, {
-      searchParams: {
-        asset_id: assetId,
-        segment: 'drilling',
-        status: 'complete'
-      }
-    }).json();
-
-    if (!data[0]) {
-      throw new Error(`Could not found streams for asset ID - ${assetId}`);
-    }
+  async getStreamsByAssetIds(assetIds, segments, statuses = ['complete']) {
+    const searchParams = new URLSearchParams([
+      ...assetIds.map((assetId) => ['asset_id[]', assetId]),
+      ...segments.map((segment) => ['segment[]', segment]),
+      ...statuses.map((status) => ['status[]', status]),
+    ]);
+
+    return this.#api.get(`v1/app_streams`, { searchParams }).json();
+  }
 
+  /**
+   * Get all assets
+   *
+   * @public
+   *
+   * @param {string} status
+   * @param {number} perPage
+   *
+   * @returns  {Promise<object[]>}
+   */
+  async getAllAssets(status = 'active', perPage = 1000) {
+    const { data } = await this.#api
+      .get(`v2/assets`, {
+        searchParams: { status, per_page: perPage },
+      })
+      .json();
     return data;
   }
 
@@ -118,7 +138,9 @@ export class Api {
    * @returns  {object[]}
    */
   async getWellByAssetId(assetId) {
-    const { wells } = await this.#api.post('v2/assets/resolve', { json: { assets: [assetId], } }).json();
+    const { wells } = await this.#api
+      .post('v2/assets/resolve', { json: { assets: [assetId] } })
+      .json();
 
     if (!wells.length) {
       throw new Error(`Could not found wells by asset ID - ${assetId}`);
@@ -176,7 +198,11 @@ export class Api {
    * @returns  {object[]}
    */
   async getAppRuns(appId) {
-    const { data } = await this.#api.get(`v2/apps/${appId}/app_runs?page=1&per_page=500&status[]=pending&status[]=in_progress&status[]=running`).json();
+    const { data } = await this.#api
+      .get(
+        `v2/apps/${appId}/app_runs?page=1&per_page=500&status[]=pending&status[]=in_progress&status[]=running`
+      )
+      .json();
 
     return data;
   }
@@ -195,10 +221,12 @@ export class Api {
     const uploadURL = `v2/apps/${appKey}/packages/upload`;
 
     try {
-      const { data } = await this.#api.post(uploadURL, {
-        headers: formData.getHeaders(),
-        body: formData,
-      }).json();
+      const { data } = await this.#api
+        .post(uploadURL, {
+          headers: formData.getHeaders(),
+          body: formData,
+        })
+        .json();
 
       return {
         id: data.id,
@@ -209,22 +237,22 @@ export class Api {
         `${JSON.parse(e.response.body).message || ''} \nPOST: ${uploadURL} failed.`,
         { cause: e }
       );
-
     }
   }
 
-
   /**
-* @param {string} appId
-* @param {string} id
-* @param {string} notes
-*
-* @returns { Promise<{id: number, status: string}>}
-*/
+   * @param {string} appId
+   * @param {string} id
+   * @param {string} notes
+   *
+   * @returns { Promise<{id: number, status: string}>}
+   */
   async addNotes(appId, id, notes) {
-    const { data } = await this.#api.patch(`v2/apps/${appId}/packages/${id}`, {
-      json: { package: { notes } },
-    }).json();
+    const { data } = await this.#api
+      .patch(`v2/apps/${appId}/packages/${id}`, {
+        json: { package: { notes } },
+      })
+      .json();
 
     return {
       id: data.id,
@@ -233,11 +261,11 @@ export class Api {
   }
 
   /**
-* @param {string} appId
-* @param {string} uploadId
-*
-* @returns { Promise<{id: number, status: string}>}
-*/
+   * @param {string} appId
+   * @param {string} uploadId
+   *
+   * @returns { Promise<{id: number, status: string}>}
+   */
   async checkApp(appId, uploadId) {
     const { data } = await this.#api.get(`v2/apps/${appId}/packages/${uploadId}`).json();
 
@@ -248,30 +276,32 @@ export class Api {
   }
 
   /**
- * @param {string} appId
- * @param {string} uploadId
- *
- * @returns { Promise<void>}
- */
+   * @param {string} appId
+   * @param {string} uploadId
+   *
+   * @returns { Promise<void>}
+   */
   deleteAppUpload(appId, uploadId) {
-    return this.#api.del(`v2/apps/${appId}/packages/${uploadId}`).json();
+    return this.#api.delete(`v2/apps/${appId}/packages/${uploadId}`).json();
   }
 
   /**
- * @param {string} appId
- * @param {string} id
- *
- * @returns { Promise<{id: number, status: string}>}
- */
+   * @param {string} appId
+   * @param {string} id
+   *
+   * @returns { Promise<{id: number, status: string}>}
+   */
   async publishApp(appId, id) {
     console.log(`v2/apps/${appId}/packages/${id}`, {
       json: { package: { status: 'published' } },
-    })
-    const { data } = await this.#api.patch(`v2/apps/${appId}/packages/${id}`, {
-      json: { package: { status: 'published' } },
-    }).json();
+    });
+    const { data } = await this.#api
+      .patch(`v2/apps/${appId}/packages/${id}`, {
+        json: { package: { status: 'published' } },
+      })
+      .json();
 
-    console.log('done')
+    console.log('done');
 
     return {
       id: data.id,
@@ -279,13 +309,13 @@ export class Api {
     };
   }
 
- /**
- * Get app packages
- * 
- * @param {string} appId
- *
- * @returns { Promise<object[]>}
- */
+  /**
+   * 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;
@@ -303,25 +333,25 @@ export class Api {
    *
    * @returns  { Promise<object> }
    */
-   async connectAppToStream(appId, streamId, settings, status='active') {
+  async connectAppToStream(appId, streamId, settings, status = 'active') {
     const json = {
       app_stream_id: streamId,
       app_id: appId,
       status,
       settings: settings,
-      scheduler_type: settings.scheduler_type
+      scheduler_type: settings.scheduler_type,
     };
 
     return this.#api.post('v1/app_connections', { json }).json();
   }
 
   /**
- * @param {string} appId
- * @param {string} id
- * @param {'BETA' | 'PROD'} label
- *
- * @returns { Promise<{id: number, status: string}>}
- */
+   * @param {string} appId
+   * @param {string} id
+   * @param {'BETA' | 'PROD'} label
+   *
+   * @returns { Promise<{id: number, status: string}>}
+   */
   async putLabel(appId, id, label) {
     await this.#api.patch(`v2/apps/${appId}/packages/${id}`, {
       json: { package: { label } },

package/lib/flows/lib/notification.js

@@ -0,0 +1,139 @@
+import chalk from 'chalk';
+import terminalLink from 'terminal-link';
+
+import { logger } from '../../helpers/logger.js';
+
+/**
+ * Console notification
+ *
+ */
+export class Notification {
+  #prefixUrl;
+
+  constructor(envName) {
+    this.#prefixUrl = `https://app${envName === 'production' ? '.' : `.${envName}.`}corva.ai`;
+  }
+
+  /**
+   * Create link
+   *
+   * @private
+   *
+   * @param {string} title
+   * @param {string} url
+   *
+   * @returns  {string}
+   */
+  _createLink(title, url) {
+    return this._addLinkDecoration(terminalLink(title, url));
+  }
+
+  /**
+   * Print to console line break
+   *
+   * @public
+   *
+   * @returns  {void}
+   */
+  printLineBreak() {
+    logger.write('\n');
+  }
+
+  /**
+   * Print to console text
+   *
+   * @public
+   *
+   * @param {string} text
+   *
+   * @returns  {void}
+   */
+  print(text) {
+    this.printLineBreak();
+    logger.write(text);
+  }
+
+  /**
+   * Add a link styles
+   *
+   * @private
+   *
+   * @param {string} context
+   *
+   * @returns  {string}
+   */
+  _addLinkDecoration(context) {
+    return chalk.blue.underline(context);
+  }
+
+  /**
+   * Add an error styles
+   *
+   * @private
+   *
+   * @param {string} context
+   *
+   * @returns  {string}
+   */
+  _addErrorDecoration(context) {
+    return chalk.red.bold(context);
+  }
+
+  /**
+   * Get stream link
+   *
+   * @public
+   *
+   * @param {string} title
+   * @param {string} streamId
+   *
+   * @returns  {string}
+   */
+  getStreamLink(title, streamId) {
+    const streamUrl = `${this.#prefixUrl}/config/streams/${streamId}`;
+    return this._createLink(title, streamUrl);
+  }
+
+  /**
+   * Print stream link
+   *
+   * @public
+   *
+   * @param {string} title
+   * @param {string} streamId
+   *
+   * @returns  {avoid}
+   */
+  printStreamLink(title, streamId) {
+    const link = this.getStreamLink(title, streamId);
+    this.print(link);
+  }
+
+  /**
+   * Get asset link
+   *
+   * @public
+   *
+   * @param {string} title
+   * @param {string} assetId
+   *
+   * @returns  {string}
+   */
+  getAssetLink(title, assetId) {
+    const assetUrl = `${this.#prefixUrl}/assets/${assetId}`;
+    return this._createLink(title, assetUrl);
+  }
+
+  /**
+   * Print an error
+   *
+   * @public
+   *
+   * @param {string} error
+   *
+   * @returns  {void}
+   */
+  printError(error) {
+    this.print(this._addErrorDecoration(error));
+  }
+}

package/lib/flows/lib/waitForMs.js

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

package/lib/flows/release.js

@@ -21,6 +21,6 @@ export const RELEASE_FLOW = {
     REMOVE_FAILED_UPLOAD_STEP,
     PUBLISH_PACKAGE_STEP,
     ADD_LABEL_STEP,
-    ADD_NOTES_STEP
+    ADD_NOTES_STEP,
   ],
 };

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

@@ -0,0 +1,24 @@
+import _ from 'lodash';
+
+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,142 @@
+import _ from 'lodash';
+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 (let 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;
+};