@corva/create-app 0.0.0-2576df8

package/lib/flows/lib/api.js

@@ -0,0 +1,385 @@
+import debugFn from 'debug';
+import got from 'got';
+import { StepError } from './step-error.js';
+import { OVERRIDE_CACHE_BEHAVIOR, DELETE_CACHE_BEHAVIOR } from './../../constants/cache.js';
+
+const debug = debugFn('cca:api');
+
+/**
+ * Connect to Corva API
+ *
+ */
+export class Api {
+  /**
+   * @type {import('got').Got}
+   */
+  #api;
+
+  constructor(envName, apiKey, authToken = null) {
+    const prefixUrl = `https://api${envName === 'production' ? '' : `.${envName}`}.corva.ai`;
+
+    this.#api = got.extend({
+      prefixUrl,
+      retry: { limit: 0 },
+      headers: {
+        'Authorization': authToken ? `Bearer ${authToken}` : `API ${apiKey}`,
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+      hooks: {
+        beforeRequest: [debug],
+      },
+    });
+  }
+
+  /**
+   * Get app by appKey
+   *
+   * @public
+   *
+   * @param {string} appKey
+   *
+   * @returns  {object}
+   */
+  async getAppByKey(appKey) {
+    try {
+      const { data } = await this.#api.get(`v2/apps/${appKey}`).json();
+
+      if (!data) {
+        throw new StepError(
+          `App with key - ${appKey}, does not exist.\nThe key search is case-sensitive. You might need to update the app key in your app to exactly match the key.`,
+        );
+      }
+
+      return data;
+    } catch (error) {
+      if (error?.response?.statusCode === 404) {
+        throw new StepError(
+          `App with key - ${appKey}, does not exist.\nThe key search is case-sensitive. You might need to update the app key in your app to exactly match the key.`,
+          { cause: error },
+        );
+      }
+      // If error has a response, it's an API exception
+      else if (error?.response) {
+        throw new StepError(`getAppByKey request failed, code:${error?.response?.statusCode}`);
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Get app datasets
+   *
+   * @public
+   *
+   * @param {string} appId
+   *
+   * @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();
+
+    return data;
+  }
+
+  /**
+   * Get asset details
+   *
+   * @public
+   *
+   * @param {string} assetId
+   *
+   * @returns  {Promise<object[]>}
+   */
+  async getAssetById(assetId) {
+    const { data } = await this.#api.get(`v2/assets/${assetId}`).json();
+
+    return data;
+  }
+
+  /**
+   * Get assets streams by ids
+   *
+   * @public
+   *
+   * @param {string[]} assetIds
+   * @param {string[]} segments
+   * @param {string[]} statuses
+   *
+   * @returns  {Promise<object[]>}
+   */
+  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[]} statuses
+   * @param {number} companyId
+   * @param {number} perPage
+   *
+   * @returns  {Promise<object[]>}
+   */
+  async getAllAssets(statuses = ['active'], companyId = null, perPage = 2000) {
+    const searchParams = [['per_page', perPage]];
+
+    if (companyId) {
+      searchParams.push(['company_id', companyId]);
+    }
+
+    if (statuses?.length) {
+      searchParams.push(...statuses.map((status) => ['status[]', status]));
+    }
+
+    const { data } = await this.#api.get(`v2/assets`, { searchParams: new URLSearchParams(searchParams) }).json();
+
+    return data;
+  }
+
+  /**
+   * Get wells data by asset id
+   *
+   * @public
+   *
+   * @param {string} assetId
+   *
+   * @returns  {object[]}
+   */
+  async getWellByAssetId(assetId) {
+    const { wells } = await this.#api
+      .post('v2/assets/resolve', {
+        json: { assets: [assetId] },
+      })
+      .json();
+
+    if (!wells || !wells.length) {
+      throw new StepError(`Could not find wells by asset ID - ${assetId}`);
+    }
+
+    return wells;
+  }
+
+  /**
+   * Queue app run for create new task
+   *
+   * @public
+   *
+   * @param {string} appId
+   * @param {string} version
+   * @param {number} interval
+   * @param {string} wellId
+   * @param {string[]} appDatasetsNames
+   * @param {string} streamId
+   * @param {number} appConnectionId
+   *
+   * @returns  {object}
+   */
+  async queueAppRun(appId, version, interval, wellId, appDatasetsNames, streamId, appConnectionId, cache) {
+    const json = {
+      cache_behavior: cache ? OVERRIDE_CACHE_BEHAVIOR : DELETE_CACHE_BEHAVIOR,
+      cache_override: cache,
+      app_run: {
+        app_stream_id: streamId,
+        well_id: wellId,
+        app_version: version,
+        datasets: appDatasetsNames,
+        settings: {
+          end: 0,
+          invokes: null,
+          records_per_event: 300,
+          start: 0,
+        },
+      },
+      app_connection_id: appConnectionId,
+    };
+
+    if (interval) {
+      json.app_run.settings.interval = interval;
+    }
+
+    const { data } = await this.#api.post(`v2/apps/${appId}/app_runs`, { json }).json();
+
+    return data;
+  }
+
+  /**
+   * Get all active(status - pending or in_progress or running) runs by app ID
+   *
+   * @public
+   *
+   * @param {string} appId
+   *
+   * @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();
+
+    return data;
+  }
+
+  /**
+   * Upload packages
+   *
+   * @public
+   *
+   * @param {string} appKey
+   * @param {object} formData
+   *
+   * @returns
+   */
+  async uploadPackages(appKey, formData) {
+    const uploadURL = `v2/apps/${appKey}/packages/upload`;
+
+    try {
+      const { data } = await this.#api
+        .post(uploadURL, {
+          headers: formData.getHeaders(),
+          body: formData,
+        })
+        .json();
+
+      return {
+        id: data.id,
+        status: data.attributes.status,
+        isDeletedDueToLimit: data.attributes.deleted_due_to_limit,
+      };
+    } catch (e) {
+      throw new StepError(`${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}>}
+   */
+  async addNotes(appId, id, notes) {
+    const { data } = await this.#api
+      .patch(`v2/apps/${appId}/packages/${id}`, {
+        json: { package: { notes } },
+      })
+      .json();
+
+    return {
+      id: data.id,
+      status: data.attributes.status,
+    };
+  }
+
+  /**
+   * @param {string} appId
+   * @param {string} uploadId
+   *
+   * @returns { Promise<{id: number, status: string, notes: string}>}
+   */
+  async checkApp(appId, uploadId) {
+    const { data } = await this.#api.get(`v2/apps/${appId}/packages/${uploadId}`).json();
+
+    return {
+      id: data.id,
+      status: data.attributes.status,
+      notes: data.attributes.notes ?? '',
+    };
+  }
+
+  /**
+   * @param {string} appId
+   * @param {string} uploadId
+   *
+   * @returns { Promise<void>}
+   */
+  deleteAppUpload(appId, uploadId) {
+    return this.#api.delete(`v2/apps/${appId}/packages/${uploadId}`).json();
+  }
+
+  /**
+   * @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();
+
+    console.log('done');
+
+    return {
+      id: data.id,
+      status: data.attributes.status,
+    };
+  }
+
+  /**
+   * 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,
+      scheduler_type: settings.scheduler_type,
+    };
+
+    return this.#api.post('v1/app_connections', { json }).json();
+  }
+
+  /**
+   * @param {string} appId
+   * @param {string} id
+   * @param {'DEV' | '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/create-zip-archive.js

@@ -0,0 +1,83 @@
+import archiver from 'archiver';
+import debugFn from 'debug';
+
+const debug = debugFn('cca:zip');
+
+import { createWriteStream, promises as fs } from 'node:fs';
+import path from 'node:path';
+
+export const createZipArchive = async (dirName, zipName, itemsToZip = []) => {
+  const filePath = path.resolve(dirName, zipName);
+  const archive = archiver.create('zip', {});
+  const output = createWriteStream(filePath);
+
+  // pipe archive data to the file
+  archive.pipe(output);
+
+  // eslint-disable-next-line no-async-promise-executor
+  await new Promise(async (resolve, reject) => {
+    output.once('close', resolve).once('end', function () {
+      debug('Data has been drained');
+    });
+
+    archive.on('warning', function (err) {
+      if (err.code === 'ENOENT') {
+        console.warn(err.message);
+
+        return;
+      }
+
+      throw err;
+    });
+
+    archive.once('error', reject);
+
+    const dataToZip = await getDataToZip(itemsToZip, dirName);
+
+    for (const item of dataToZip) {
+      if (item.isDir) {
+        debug(`Adding directory %s -> %s`, item.path, item.name);
+        archive.directory(item.path, item.name);
+
+        continue;
+      }
+
+      debug(`Adding file %s -> %s`, item.path, item.name);
+      archive.file(item.path, { name: item.name });
+    }
+
+    archive.finalize();
+  });
+
+  return archive.pointer();
+};
+
+const getDataToZip = async (itemsToZip, dirName) => {
+  const promises = itemsToZip.map(async (name) => {
+    const nameWasProvided = typeof name === 'string';
+    const filePath = nameWasProvided ? path.resolve(dirName, name) : name.path;
+    const fileName = nameWasProvided ? name : name.name;
+
+    const { exists, isDir } = await fs
+      .lstat(filePath)
+      .then((stat) => ({
+        exists: true,
+        isDir: stat.isDirectory(),
+      }))
+      .catch(() => {
+        debug(`%s location not exist, filtering it out`, filePath);
+
+        return { exists: false, isDir: false };
+      });
+
+    return {
+      name: fileName,
+      path: filePath,
+      exists,
+      isDir,
+    };
+  });
+  const allData = await Promise.all(promises);
+
+  return allData.filter((f) => f.exists);
+};

package/lib/flows/lib/json.js

@@ -0,0 +1,30 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import { resolve } from 'node:path';
+
+import debugFn from 'debug';
+import { StepError } from './step-error.js';
+
+const debug = debugFn('cca:json');
+
+export const loadJson = async (dirName, fileName) => {
+  const fullPath = resolve(dirName, fileName);
+
+  try {
+    debug('Loading file %s', fullPath);
+
+    const manifest = await fs.readFile(fullPath, 'utf8');
+
+    return JSON.parse(manifest);
+  } catch (e) {
+    if (e.code === 'ENOENT') {
+      throw new StepError(`${fileName} was not found in ${resolve(dirName)}`, { cause: e });
+    }
+
+    throw e;
+  }
+};
+
+export const saveJson = async (dirName, fileName, data) => {
+  return fs.writeFile(resolve(dirName, fileName), JSON.stringify(data, null, 2) + os.EOL);
+};

package/lib/flows/lib/manifest.js

@@ -0,0 +1,81 @@
+import set from 'lodash/set.js';
+import { APP_TYPES, APP_RUNTIMES } from '../../constants/cli.js';
+import {
+  SCHEDULER_TYPE_DATA_TIME,
+  SCHEDULER_TYPE_DEPTH,
+  SCHEDULER_TYPE_NATURAL_TIME,
+} from '../../constants/manifest.js';
+
+const SCHEDULER_MAPPING = [SCHEDULER_TYPE_DATA_TIME, SCHEDULER_TYPE_DEPTH, SCHEDULER_TYPE_NATURAL_TIME].reduce(
+  (acc, type) => set(acc, type.value, type.name.toLowerCase().replace(/ /, '-')),
+  {},
+);
+
+const NODE_RUNTIMES = [APP_RUNTIMES.NODE18, APP_RUNTIMES.NODE20, APP_RUNTIMES.NODE22, APP_RUNTIMES.NODE24];
+
+export class Manifest {
+  constructor(manifest) {
+    this.manifest = manifest;
+  }
+
+  get runtime() {
+    return this.manifest.settings.runtime;
+  }
+
+  get type() {
+    return this.manifest.application.type;
+  }
+
+  get subtype() {
+    if (this.isScheduler()) {
+      return SCHEDULER_MAPPING[this.manifest.settings.app.scheduler_type];
+    }
+
+    if (this.isStream()) {
+      return this.manifest.settings.app.log_type;
+    }
+
+    return '';
+  }
+
+  get templateName() {
+    return this.type + (this.isScheduler() || this.isStream() ? `_${this.subtype}` : '');
+  }
+
+  get name() {
+    return this.manifest.application.name;
+  }
+
+  get unix_name() {
+    // todo: npm scopes?
+    return this.manifest.application.key.replace(/\W+/gi, '_').toLowerCase();
+  }
+
+  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.startsWith('python');
+  }
+
+  isScheduler() {
+    return this.manifest.application.type === APP_TYPES.SCHEDULER;
+  }
+
+  isStream() {
+    return this.manifest.application.type === APP_TYPES.STREAM;
+  }
+}

package/lib/flows/lib/notification.js

@@ -0,0 +1,142 @@
+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));
+  }
+}