clever-tools 3.7.0 → 3.8.0

package/src/commands/tcp-redirs.js

@@ -2,32 +2,68 @@
 
 const colors = require('colors/safe');
 
-const AppConfig = require('../models/app_configuration.js');
-const Organisation = require('../models/organisation.js');
+const Namespaces = require('../models/namespaces.js');
 const { sendToApi } = require('../models/send-to-api.js');
 const Interact = require('../models/interact.js');
 const Logger = require('../logger.js');
 const application = require('@clevercloud/client/cjs/api/v2/application.js');
+const Application = require('../models/application.js');
 
 async function listNamespaces (params) {
-  const namespaces = await Organisation.getNamespaces(params);
+  const { alias, app: appIdOrName, format } = params.options;
+  const { ownerId } = await Application.resolveId(appIdOrName, alias);
 
-  Logger.println('Available namespaces: ' + namespaces.map(({ namespace }) => namespace).join(', '));
-};
+  const namespaces = await Namespaces.getNamespaces(ownerId);
+
+  namespaces.sort((a, b) => a.namespace.localeCompare(b.namespace));
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(namespaces);
+      break;
+    }
+    case 'human':
+    default: {
+      Logger.println('Available namespaces:');
+      namespaces.forEach(({ namespace }) => {
+        switch (namespace) {
+          case 'cleverapps':
+            Logger.println(`- ${namespace}: for redirections used with 'cleverapps.io' domain`);
+            break;
+          case 'default':
+            Logger.println(`- ${namespace}: for redirections used with custom domains`);
+            break;
+          default:
+            Logger.println(`- ${namespace}`);
+        }
+      });
+      break;
+    }
+  }
+}
 
 async function list (params) {
-  const { alias } = params.options;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { alias, app: appIdOrName, format } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   const redirs = await application.getTcpRedirs({ id: ownerId, appId }).then(sendToApi);
 
-  if (redirs.length === 0) {
-    Logger.println('No active TCP redirection for this application');
-  }
-  else {
-    Logger.println('Enabled TCP redirections:');
-    for (const { namespace, port } of redirs) {
-      Logger.println(port + ' on ' + namespace);
+  switch (format) {
+    case 'json': {
+      Logger.printJson(redirs);
+      break;
+    }
+    case 'human':
+    default: {
+      if (redirs.length === 0) {
+        Logger.println('No active TCP redirection for this application');
+      }
+      else {
+        Logger.println('Enabled TCP redirections:');
+        for (const { namespace, port } of redirs) {
+          Logger.println(port + ' on ' + namespace);
+        }
+      }
     }
   }
 }
@@ -46,8 +82,8 @@ async function acceptPayment (result, skipConfirmation) {
 }
 
 async function add (params) {
-  const { alias, namespace, yes: skipConfirmation } = params.options;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { alias, app: appIdOrName, namespace, yes: skipConfirmation } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   const { port } = await application.addTcpRedir({ id: ownerId, appId }, { namespace }).then(sendToApi).catch((error) => {
     if (error.status === 402) {
@@ -65,8 +101,8 @@ async function add (params) {
 
 async function remove (params) {
   const [port] = params.args;
-  const { alias, namespace } = params.options;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { alias, app: appIdOrName, namespace } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   await application.removeTcpRedir({ id: ownerId, appId, sourcePort: port, namespace }).then(sendToApi);
 

package/src/commands/webhooks.js

@@ -8,29 +8,44 @@ const { getOwnerAndApp, getOrgaIdOrUserId } = require('../models/notification.js
 const { getWebhooks, createWebhook, deleteWebhook } = require('@clevercloud/client/cjs/api/v2/notification.js');
 const { sendToApi } = require('../models/send-to-api.js');
 
-function displayWebhook (hook) {
-  Logger.println((hook.name && colors.bold(hook.name)) || hook.id);
-  Logger.println(`  id: ${hook.id}`);
-  Logger.println(`  services: ${(hook.scope && hook.scope.join(', ')) || hook.ownerId}`);
-  Logger.println(`  events: ${(hook.events && hook.events.join(', ')) || colors.bold('ALL')}`);
-  Logger.println('  hooks:');
-  hook.urls.forEach((url) => Logger.println(`    ${url.url} (${url.format})`));
-  Logger.println();
-}
-
 async function list (params) {
-  const { org, 'list-all': listAll } = params.options;
+  const { org, 'list-all': listAll, format } = params.options;
 
   // TODO: fix alias option
   const { ownerId, appId } = await getOwnerAndApp(null, org, !listAll);
   const hooks = await getWebhooks({ ownerId }).then(sendToApi);
 
-  hooks
+  const formattedHooks = hooks
     .filter((hook) => {
       const emptyScope = !hook.scope || hook.scope.length === 0;
       return !appId || emptyScope || hook.scope.includes(appId);
     })
-    .forEach((hook) => displayWebhook(hook));
+    .map((hook) => ({
+      id: hook.id,
+      name: hook.name,
+      ownerId: hook.ownerId,
+      services: hook.scope ?? [hook.ownerId],
+      events: hook.events ?? ['ALL'],
+      urls: hook.urls,
+    }));
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(formattedHooks);
+      break;
+    }
+    case 'human':
+    default: {
+      formattedHooks.forEach((hook) => {
+        Logger.println(hook.name ? colors.bold(hook.name) : hook.id);
+        Logger.println(`  id: ${hook.id}`);
+        Logger.println(`  services: ${hook.services.join(', ')}`);
+        Logger.println(`  events: ${hook.events.join(', ')}`);
+        Logger.println('  hooks:');
+        hook.urls.forEach((url) => Logger.println(`    ${url.url} (${url.format})`));
+      });
+    }
+  }
 }
 
 async function add (params) {

package/src/logger.js

@@ -28,20 +28,24 @@ function formatLines (prefixLength, lines) {
     .join('\n');
 }
 
+function consoleErrorWithoutColor (line) {
+  process.stderr.write(line + '\n');
+}
+
 const Logger = _(['debug', 'info', 'warn', 'error'])
   .map((severity) => {
     if (process.env.CLEVER_QUIET || (!process.env.CLEVER_VERBOSE && (severity === 'debug' || severity === 'info'))) {
       return [severity, _.noop];
     }
-    const consoleFn = (severity === 'error') ? console.error : console.log;
+    const consoleFn = (severity === 'error') ? consoleErrorWithoutColor : console.log;
     const { prefix, prefixLength } = getPrefix(severity);
     return [severity, (err) => {
       const message = _.get(err, 'message', err);
       const formattedMsg = formatLines(prefixLength, processApiError(message));
       if (process.env.CLEVER_VERBOSE && severity === 'error') {
-        console.error('[STACKTRACE]');
-        console.error(err);
-        console.error('[/STACKTRACE]');
+        consoleErrorWithoutColor('[STACKTRACE]');
+        consoleErrorWithoutColor(err);
+        consoleErrorWithoutColor('[/STACKTRACE]');
       }
       return consoleFn(`${prefix}${formattedMsg}`);
     }];
@@ -57,8 +61,7 @@ Logger.printJson = (obj) => {
   console.log(JSON.stringify(obj, null, 2));
 };
 
-// No decoration for Logger.printErrorLine
-Logger.printErrorLine = console.error;
+Logger.printErrorLine = consoleErrorWithoutColor;
 
 // Only exported for testing, shouldn't be used directly
 Logger.processApiError = processApiError;

package/src/models/app_configuration.js

@@ -54,13 +54,21 @@ async function addLinkedApplication (appData, alias, ignoreParentConfig) {
   return persistConfig(currentConfig);
 };
 
-async function removeLinkedApplication (alias) {
+async function removeLinkedApplication ({ appId, alias }) {
   const currentConfig = await loadApplicationConf();
   const newConfig = {
     ...currentConfig,
-    apps: currentConfig.apps.filter((appEntry) => appEntry.alias !== alias),
+    apps: currentConfig.apps.filter((appEntry) => {
+      return appEntry.app_id !== appId && appEntry.alias !== alias;
+    }),
   };
-  return persistConfig(newConfig);
+
+  if (currentConfig.apps.length !== newConfig.apps.length) {
+    await persistConfig(newConfig);
+    return true;
+  }
+
+  return false;
 };
 
 function findApp (config, alias) {

package/src/models/application.js

@@ -4,6 +4,7 @@ const _ = require('lodash');
 const application = require('@clevercloud/client/cjs/api/v2/application.js');
 const autocomplete = require('cliparse').autocomplete;
 const product = require('@clevercloud/client/cjs/api/v2/product.js');
+const { getSummary } = require('@clevercloud/client/cjs/api/v2/user.js');
 
 const AppConfiguration = require('./app_configuration.js');
 const Interact = require('./interact.js');
@@ -12,6 +13,8 @@ const Organisation = require('./organisation.js');
 const User = require('./user.js');
 
 const { sendToApi } = require('../models/send-to-api.js');
+const AppConfig = require('./app_configuration.js');
+const { resolveOwnerId } = require('./ids-resolver.js');
 
 function listAvailableTypes () {
   return autocomplete.words(['docker', 'elixir', 'go', 'gradle', 'haskell', 'jar', 'maven', 'meteor', 'node', 'php', 'play1', 'play2', 'python', 'ruby', 'rust', 'sbt', 'static-apache', 'war']);
@@ -86,20 +89,58 @@ async function create (name, typeName, region, orgaIdOrName, github, isTask, env
   return application.create({ id: ownerId }, newApp).then(sendToApi);
 };
 
-async function deleteApp (addDetails, skipConfirmation) {
-  Logger.debug('Deleting app: ' + addDetails.name + ' (' + addDetails.appId + ')');
+async function deleteApp (app, skipConfirmation) {
+  Logger.debug('Deleting app: ' + app.name + ' (' + app.id + ')');
 
   if (!skipConfirmation) {
     await Interact.confirm(
-      `Deleting the application ${addDetails.name} can't be undone, please type '${addDetails.name}' to confirm: `,
+      `Deleting the application ${app.name} can't be undone, please type '${app.name}' to confirm: `,
       'No confirmation, aborting application deletion',
-      [addDetails.name],
+      [app.name],
     );
   }
 
-  return application.remove({ id: addDetails.ownerId, appId: addDetails.appId }).then(sendToApi);
+  return application.remove({ id: app.ownerId, appId: app.id }).then(sendToApi);
 };
 
+async function getAllApps (ownerId) {
+
+  const summary = await getSummary().then(sendToApi);
+
+  const orgaWithApps = await Promise.all(
+    summary.organisations
+      // If owner ID is present, only keep the matching org
+      .filter((org) => ownerId == null || org.id === ownerId)
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .map(async (org) => {
+        const applications = await getApplicationsForOwner(org.id);
+        return {
+          id: org.id,
+          name: org.name,
+          applications: applications.sort((a, b) => a.name.localeCompare(b.name)),
+        };
+      }),
+  );
+
+  return orgaWithApps;
+};
+
+async function getApplicationsForOwner (ownerId) {
+  const rawApplications = await application.getAll({ id: ownerId }).then(sendToApi);
+  return rawApplications.map((app) => {
+    return {
+      app_id: app.id,
+      org_id: ownerId,
+      name: app.name,
+      zone: app.zone,
+      type: app.instance.variant.slug,
+      createdAt: new Date(app.creationDate).toISOString(),
+      deploy_url: app.deployment.httpUrl,
+      git_ssh_url: app.deployment.url,
+    };
+  });
+}
+
 function getApplicationByName (apps, name) {
   const filteredApps = apps.filter((app) => app.name === name);
   if (filteredApps.length === 1) {
@@ -129,6 +170,62 @@ function getFromSelf (appId) {
   return application.get({ appId }).then(sendToApi);
 };
 
+/**
+ * @param {{app_id: string}|{app_name: string}} appIdOrName
+ * @param {string} alias
+ * @return {Promise<{appId: string, ownerId: string}>}
+ */
+async function resolveId (appIdOrName, alias) {
+  if (appIdOrName != null && alias != null) {
+    throw new Error('Only one of the `--app` or `--alias` options can be set at a time');
+  }
+
+  // -- resolve by linked app
+
+  if (appIdOrName == null) {
+    const appDetails = await AppConfig.getAppDetails({ alias });
+    return { appId: appDetails.appId, ownerId: appDetails.ownerId };
+  }
+
+  // -- resolve by app id
+
+  if (appIdOrName.app_id != null) {
+    const ownerId = await resolveOwnerId(appIdOrName.app_id);
+    if (ownerId != null) {
+      return {
+        appId: appIdOrName.app_id,
+        ownerId,
+      };
+    }
+
+    throw new Error('Application not found');
+  }
+
+  // -- resolve by app name
+
+  const summary = await getSummary({}).then(sendToApi);
+
+  const candidates = [summary.user, ...summary.organisations]
+    .flatMap((owner) => owner.applications.map((app) => ({ app, owner })))
+    .filter((candidate) => candidate.app.name === appIdOrName.app_name);
+
+  if (candidates.length === 0) {
+    throw new Error('Application not found');
+  }
+  if (candidates.length === 1) {
+    return {
+      appId: candidates[0].app.id,
+      ownerId: candidates[0].owner.id,
+    };
+  }
+
+  Logger.printErrorLine(`The name '${appIdOrName.app_name}' refers to multiple applications:`);
+  candidates.forEach((candidate) => {
+    Logger.printErrorLine(`- ${candidate.owner.name}: ${candidate.app.id} (${candidate.app.variantSlug})`);
+  });
+  throw new Error('Ambiguous application name, use the `--app` option with one of the IDs above');
+}
+
 async function linkRepo (app, orgaIdOrName, alias, ignoreParentConfig) {
   Logger.debug(`Linking current repository to the app: ${app.app_id || app.app_name}`);
 
@@ -145,7 +242,7 @@ async function linkRepo (app, orgaIdOrName, alias, ignoreParentConfig) {
 
 function unlinkRepo (alias) {
   Logger.debug(`Unlinking current repository from the app: ${alias}`);
-  return AppConfiguration.removeLinkedApplication(alias);
+  return AppConfiguration.removeLinkedApplication({ alias });
 };
 
 function redeploy (ownerId, appId, commit, withoutCache) {
@@ -214,7 +311,7 @@ async function listDependencies (ownerId, appId, showAll) {
   const applicationDeps = await application.getAllDependencies({ id: ownerId, appId }).then(sendToApi);
 
   if (!showAll) {
-    return applicationDeps;
+    return applicationDeps.map((app) => ({ ...app, isLinked: true }));
   }
 
   const allApps = await application.getAll({ id: ownerId }).then(sendToApi);
@@ -237,9 +334,11 @@ async function unlink (ownerId, appId, dependency) {
 };
 
 module.exports = {
+  resolveId,
   create,
   deleteApp,
   get,
+  getAllApps,
   link,
   linkRepo,
   listAvailableAliases,

package/src/models/exit-strategy-option.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const colors = require('colors/safe');
+const Logger = require('../logger.js');
+
+function get (follow, exitOnDeploy) {
+  if (follow) {
+    if (exitOnDeploy === 'deploy-start') {
+      throw new Error('The `follow` and `exit-on` set to "deploy-start" options are not compatible');
+    }
+    Logger.println(colors.yellow('The `follow` option is deprecated and will be removed in an upcoming major, use --exit-on set to "never" instead'));
+    return 'never';
+  }
+  return exitOnDeploy;
+}
+
+// plotQuietWarning: If in quiet mode and exitStrategy set to never plot a warning to indicate that the command will end
+function plotQuietWarning (exitStrategy, quiet) {
+  if (exitStrategy === 'never' && quiet) {
+    Logger.println(colors.bold.yellow('The "never" exit-on strategy is not compatible with the "quiet" mode, it will exit once the deployment ends'));
+  }
+}
+
+module.exports = { get, plotQuietWarning };

package/src/models/json-array.js

@@ -0,0 +1,28 @@
+/**
+ * Helper to print a real JSON array with starting `[` and ending `]`
+ */
+class JsonArray {
+  constructor () {
+    this._isFirst = true;
+  }
+
+  open () {
+    process.stdout.write('[\n');
+  }
+
+  push (log) {
+    if (this._isFirst) {
+      this._isFirst = false;
+    }
+    else {
+      process.stdout.write(',\n');
+    }
+    process.stdout.write(`  ${JSON.stringify(log)}`);
+  }
+
+  close () {
+    process.stdout.write('\n]');
+  }
+}
+
+module.exports = { JsonArray };

package/src/models/log-v4.js

@@ -4,6 +4,8 @@ const { Deferred } = require('./utils.js');
 const Logger = require('../logger.js');
 const { waitForDeploymentEnd, waitForDeploymentStart } = require('./deployments.js');
 const { ApplicationLogStream } = require('@clevercloud/client/cjs/streams/application-logs.js');
+const { JsonArray } = require('./json-array.js');
+const ExitStrategy = require('../models/exit-strategy-option.js');
 
 // 2000 logs per 100ms maximum
 const THROTTLE_ELEMENTS = 2000;
@@ -90,15 +92,20 @@ async function watchDeploymentAndDisplayLogs (options) {
     commitId,
     knownDeployments,
     quiet,
-    follow,
     redeployDate,
+    exitStrategy,
   } = options;
 
+  ExitStrategy.plotQuietWarning(exitStrategy, quiet);
   // If in quiet mode, we only log start/finished deployment messages
   !quiet && Logger.println('Waiting for deployment to start…');
   const deployment = await waitForDeploymentStart({ ownerId, appId, deploymentId, commitId, knownDeployments });
   Logger.println(colors.bold.blue(`Deployment started (${deployment.uuid})`));
 
+  if (exitStrategy === 'deploy-start') {
+    return;
+  }
+
   const deferred = new Deferred();
   let logsStream;
 
@@ -120,7 +127,7 @@ async function watchDeploymentAndDisplayLogs (options) {
     deferred.promise,
   ]);
 
-  if (!quiet && !follow) {
+  if (!quiet && exitStrategy !== 'never') {
     logsStream.close(quiet ? 'quiet' : 'follow');
   }
 
@@ -166,30 +173,3 @@ function isBuildSucessMessage (log) {
 };
 
 module.exports = { displayLogs, watchDeploymentAndDisplayLogs };
-
-/**
- * Helper to print a real JSON array with starting `[` and ending `]`
- */
-class JsonArray {
-  constructor () {
-    this._isFirst = true;
-  }
-
-  open () {
-    process.stdout.write('[\n');
-  }
-
-  push (log) {
-    if (this._isFirst) {
-      this._isFirst = false;
-    }
-    else {
-      process.stdout.write(',\n');
-    }
-    process.stdout.write(`  ${JSON.stringify(log)}`);
-  }
-
-  close () {
-    process.stdout.write('\n]');
-  }
-}

package/src/models/log.js

@@ -9,6 +9,7 @@ const { getOldLogs } = require('@clevercloud/client/cjs/api/v2/log.js');
 const { LogsStream } = require('@clevercloud/client/cjs/streams/logs.node.js');
 const { sendToApi, getHostAndTokens } = require('./send-to-api.js');
 const { waitForDeploymentEnd, waitForDeploymentStart } = require('./deployments.js');
+const ExitStrategy = require('../models/exit-strategy-option.js');
 
 function isCleverMessage (line) {
   return line._source.syslog_program === '/home/bas/rubydeployer/deployer.rb';
@@ -100,12 +101,18 @@ async function displayLogs ({ appAddonId, until, since, filter, deploymentId })
   return deferred.promise;
 }
 
-async function watchDeploymentAndDisplayLogs ({ ownerId, appId, deploymentId, commitId, knownDeployments, quiet, follow }) {
+async function watchDeploymentAndDisplayLogs ({ ownerId, appId, deploymentId, commitId, knownDeployments, quiet, exitStrategy }) {
 
+  ExitStrategy.plotQuietWarning(exitStrategy, quiet);
+  // If in quiet mode, we only log start/finished deployment messages
   Logger.println('Waiting for deployment to start…');
   const deployment = await waitForDeploymentStart({ ownerId, appId, deploymentId, commitId, knownDeployments });
   Logger.println(colors.bold.blue(`Deployment started (${deployment.uuid})`));
 
+  if (exitStrategy === 'deploy-start') {
+    return;
+  }
+
   const deferred = new Deferred();
   let logsStream;
 
@@ -127,7 +134,7 @@ async function watchDeploymentAndDisplayLogs ({ ownerId, appId, deploymentId, co
     deferred.promise,
   ]);
 
-  if (!quiet && !follow) {
+  if (!quiet && exitStrategy !== 'never') {
     logsStream.close();
   }
 

package/src/models/namespaces.js

@@ -0,0 +1,20 @@
+const Application = require('./application.js');
+const organisation = require('@clevercloud/client/cjs/api/v2/organisation.js');
+const { sendToApi } = require('./send-to-api.js');
+const { autocomplete } = require('cliparse');
+
+async function getNamespaces (ownerId) {
+  return organisation.getNamespaces({ id: ownerId }).then(sendToApi);
+}
+
+async function completeNamespaces () {
+  // Sadly we do not have access to current params in complete as of now
+  const { ownerId } = await Application.resolveId(null, null);
+
+  return getNamespaces(ownerId).then(autocomplete.words);
+}
+
+module.exports = {
+  getNamespaces,
+  completeNamespaces,
+};

package/src/models/organisation.js

@@ -1,11 +1,7 @@
 'use strict';
 
 const _ = require('lodash');
-const autocomplete = require('cliparse').autocomplete;
 
-const AppConfig = require('./app_configuration.js');
-
-const organisation = require('@clevercloud/client/cjs/api/v2/organisation.js');
 const { getSummary } = require('@clevercloud/client/cjs/api/v2/user.js');
 const { sendToApi } = require('../models/send-to-api.js');
 
@@ -37,22 +33,6 @@ async function getByName (name) {
   return filteredOrgs[0];
 }
 
-async function getNamespaces (params) {
-  const { alias } = params.options;
-  const { ownerId } = await AppConfig.getAppDetails({ alias });
-
-  return organisation.getNamespaces({ id: ownerId }).then(sendToApi);
-}
-
-function completeNamespaces () {
-  // Sadly we do not have access to current params in complete as of now
-  const params = { options: {} };
-
-  return getNamespaces(params).then(autocomplete.words);
-};
-
 module.exports = {
   getId,
-  getNamespaces,
-  completeNamespaces,
 };

package/src/models/utils.js

@@ -15,4 +15,11 @@ class Deferred {
   }
 }
 
-module.exports = { Deferred };
+function truncateWithEllipsis (length, string) {
+  if (string.length > length - 1) {
+    return string.substring(0, length - 1) + '…';
+  }
+  return string;
+}
+
+module.exports = { Deferred, truncateWithEllipsis };