clever-tools 3.7.0 → 3.8.0

package/src/commands/notify-email.js

@@ -8,34 +8,49 @@ const { getOwnerAndApp, getOrgaIdOrUserId } = require('../models/notification.js
 const { getEmailhooks, createEmailhook, deleteEmailhook } = require('@clevercloud/client/cjs/api/v2/notification.js');
 const { sendToApi } = require('../models/send-to-api.js');
 
-function displayEmailhook (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')}`);
-  if (hook.notified) {
-    Logger.println('  to:');
-    hook.notified.forEach((target) => Logger.println(`    ${target.target || 'whole team'}`));
-  }
-  else {
-    Logger.println('  to: whole team');
-  }
-  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 getEmailhooks({ 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) => displayEmailhook(hook));
+    .map((hook) => ({
+      id: hook.id,
+      name: hook.name,
+      ownerId: hook.ownerId,
+      services: hook.scope ?? [hook.ownerId],
+      events: hook.events ?? ['ALL'],
+      notified: hook.notified ? hook.notified.map(({ target }) => target ?? 'whole team') : ['whole team'],
+    }));
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(formattedHooks);
+      break;
+    }
+    case 'human':
+    default: {
+      formattedHooks.forEach((hook, i) => {
+        Logger.println(colors.bold(hook.name ?? hook.id));
+        Logger.println(`  id: ${hook.id}`);
+        Logger.println(`  services: ${hook.services.join(', ')}`);
+        Logger.println(`  events: ${hook.events.join(', ')}`);
+        if (hook.notified.length > 1) {
+          Logger.println('  to:');
+          hook.notified.forEach((target) => Logger.println(`    ${target}`));
+        }
+        else {
+          Logger.println(`  to: ${hook.notified[0]}`);
+        }
+      });
+    }
+  }
 }
 
 function getEmailNotificationTargets (notifTargets) {

package/src/commands/open.js

@@ -2,13 +2,13 @@
 
 const openPage = require('open');
 
-const AppConfig = require('../models/app_configuration.js');
+const Application = require('../models/application.js');
 const Domain = require('../models/domain.js');
 const Logger = require('../logger.js');
 
 async function open (params) {
-  const { alias } = params.options;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { alias, app: appIdOrName } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   const vhost = await Domain.getBest(appId, ownerId);
   const url = 'https://' + vhost.fqdn;

package/src/commands/profile.js

@@ -5,15 +5,35 @@ const colors = require('colors/safe');
 const Logger = require('../logger.js');
 const User = require('../models/user.js');
 
-async function profile () {
-  const { id, name, email, preferredMFA } = await User.getCurrent();
-  const has2FA = (preferredMFA != null && preferredMFA !== 'NONE') ? 'yes' : 'no';
-  const formattedName = name || colors.red.bold('[not specified]');
-  Logger.println('You\'re currently logged in as:');
-  Logger.println('User id          ' + id);
-  Logger.println('Name             ' + formattedName);
-  Logger.println('Email            ' + email);
-  Logger.println('Two factor auth  ' + has2FA);
+async function profile (params) {
+  const { format } = params.options;
+
+  const user = await User.getCurrent();
+
+  const formattedUser = {
+    id: user.id,
+    email: user.email,
+    name: user.name,
+    avatar: user.avatar,
+    creationDate: new Date(user.creationDate),
+    lang: user.lang,
+    has2FA: (user.preferredMFA != null && user.preferredMFA !== 'NONE'),
+  };
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(formattedUser);
+      break;
+    }
+    case 'human':
+    default: {
+      Logger.println('You\'re currently logged in as:');
+      Logger.println(`User id          ${formattedUser.id}`);
+      Logger.println(`Name             ${formattedUser.name ?? colors.red.bold('[not specified]')}`);
+      Logger.println(`Email            ${formattedUser.email}`);
+      Logger.println(`Two factor auth  ${formattedUser.has2FA ? 'yes' : 'no'}`);
+    }
+  }
 };
 
 module.exports = { profile };

package/src/commands/published-config.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const AppConfig = require('../models/app_configuration.js');
+const Application = require('../models/application.js');
 const Logger = require('../logger.js');
 const variables = require('../models/variables.js');
 const { sendToApi } = require('../models/send-to-api.js');
@@ -8,27 +8,38 @@ const { toNameEqualsValueString, validateName } = require('@clevercloud/client/c
 const application = require('@clevercloud/client/cjs/api/v2/application.js');
 
 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 publishedConfigs = await application.getAllExposedEnvVars({ id: ownerId, appId }).then(sendToApi);
-  const pairs = Object.entries(publishedConfigs)
-    .map(([name, value]) => ({ name, value }));
-
-  Logger.println('# Published configs');
-  Logger.println(toNameEqualsValueString(pairs));
-};
+  const pairs = Object.entries(publishedConfigs).map(([name, value]) => ({ name, value }));
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(pairs);
+      break;
+    }
+    case 'shell':
+      Logger.println(toNameEqualsValueString(pairs, { addExports: true }));
+      break;
+    case 'human':
+    default: {
+      Logger.println('# Published configs');
+      Logger.println(toNameEqualsValueString(pairs, { addExports: false }));
+    }
+  }
+}
 
 async function set (params) {
   const [varName, varValue] = params.args;
-  const { alias } = params.options;
+  const { alias, app: appIdOrName } = params.options;
 
   const nameIsValid = validateName(varName);
   if (!nameIsValid) {
     throw new Error(`Published config name ${varName} is invalid`);
   }
 
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   const publishedConfigs = await application.getAllExposedEnvVars({ id: ownerId, appId }).then(sendToApi);
   publishedConfigs[varName] = varValue;
@@ -39,8 +50,8 @@ async function set (params) {
 
 async function rm (params) {
   const [varName] = params.args;
-  const { alias } = params.options;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { alias, app: appIdOrName } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   const publishedConfigs = await application.getAllExposedEnvVars({ id: ownerId, appId }).then(sendToApi);
   delete publishedConfigs[varName];
@@ -50,9 +61,9 @@ async function rm (params) {
 };
 
 async function importEnv (params) {
-  const { alias, json } = params.options;
+  const { alias, app: appIdOrName, json } = params.options;
   const format = json ? 'json' : 'name-equals-value';
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   const publishedConfigs = await variables.readVariablesFromStdin(format);
   await application.updateAllExposedEnvVars({ id: ownerId, appId }, publishedConfigs).then(sendToApi);

package/src/commands/restart.js

@@ -2,26 +2,33 @@
 
 const colors = require('colors/safe');
 
-const AppConfig = require('../models/app_configuration.js');
 const Application = require('../models/application.js');
 const git = require('../models/git.js');
 const Log = require('../models/log-v4.js');
 const Logger = require('../logger.js');
+const ExitStrategy = require('../models/exit-strategy-option.js');
 
 // Once the API call to redeploy() has been triggerred successfully,
 // the rest (waiting for deployment state to evolve and displaying logs) is done with auto retry (resilient to network pb)
 async function restart (params) {
-  const { alias, quiet, commit, 'without-cache': withoutCache, follow } = params.options;
+  const { alias, app: appIdOrName, quiet, commit, 'without-cache': withoutCache, follow, 'exit-on': exitOnDeploy } = params.options;
 
-  const { ownerId, appId, name: appName } = await AppConfig.getAppDetails({ alias });
+  const exitStrategy = ExitStrategy.get(follow, exitOnDeploy);
+
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
   const fullCommitId = await git.resolveFullCommitId(commit);
   const app = await Application.get(ownerId, appId);
+
+  if (app == null) {
+    throw new Error('The application doesn\'t exist');
+  }
+
   const remoteCommitId = app.commitId;
 
   const commitId = fullCommitId || remoteCommitId;
   if (commitId != null) {
     const cacheSuffix = withoutCache ? ' without using cache' : '';
-    Logger.println(`Restarting ${appName} on commit ${colors.green(commitId)}${cacheSuffix}`);
+    Logger.println(`Restarting ${app.name} on commit ${colors.green(commitId)}${cacheSuffix}`);
   }
 
   // This should be handled by the API when a deployment ID is set but we'll do this for now
@@ -34,8 +41,8 @@ async function restart (params) {
     appId,
     deploymentId: redeploy.deploymentId,
     quiet,
-    follow,
     redeployDate,
+    exitStrategy,
   });
 }
 

package/src/commands/scale.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const AppConfig = require('../models/app_configuration.js');
 const Application = require('../models/application.js');
 const Logger = require('../logger.js');
 
@@ -45,9 +44,9 @@ function validateOptions (options) {
 }
 
 async function scale (params) {
-  const { alias } = params.options;
+  const { alias, app: appIdOrName } = params.options;
   const { minFlavor, maxFlavor, minInstances, maxInstances, buildFlavor } = validateOptions(params.options);
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   await Application.setScalability(appId, ownerId, {
     minFlavor,

package/src/commands/service.js

@@ -1,62 +1,89 @@
 'use strict';
 
 const Addon = require('../models/addon.js');
-const AppConfig = require('../models/app_configuration.js');
 const Application = require('../models/application.js');
 const Logger = require('../logger.js');
 
 async function list (params) {
-  const { alias, 'show-all': showAll, 'only-apps': onlyApps, 'only-addons': onlyAddons } = params.options;
+  const { alias, app: appIdOrName, 'show-all': showAll, 'only-apps': onlyApps, 'only-addons': onlyAddons, format } = params.options;
   if (onlyApps && onlyAddons) {
     throw new Error('--only-apps and --only-addons are mutually exclusive');
   }
 
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+  const formattedServices = {};
 
   if (!onlyAddons) {
     const apps = await Application.listDependencies(ownerId, appId, showAll);
-    Logger.println('Applications:');
-    apps.forEach(({ isLinked, name }) => Logger.println(`${isLinked ? '*' : ' '} ${name}`));
+    formattedServices.applications = apps.map((app) => ({
+      id: app.id,
+      name: app.name,
+      isLinked: app.isLinked,
+    }));
   }
 
   if (!onlyApps) {
     const addons = await Addon.list(ownerId, appId, showAll);
-    Logger.println('Addons:');
-    addons.forEach(({ isLinked, name, realId }) => Logger.println(`${isLinked ? '*' : ' '} ${name} (${realId})`));
+    formattedServices.addons = addons.map((addon) => ({
+      id: addon.id,
+      realId: addon.realId,
+      name: addon.name,
+      isLinked: addon.isLinked,
+    }));
+  }
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(formattedServices);
+      break;
+    }
+    case 'human':
+    default: {
+      if (formattedServices.applications) {
+        Logger.println('Applications:');
+        formattedServices.applications.forEach(({ isLinked, name }) => Logger.println(`${isLinked ? '*' : ' '} ${name}`));
+      }
+
+      if (formattedServices.addons) {
+        Logger.println('Addons:');
+        formattedServices.addons.forEach(({ isLinked, name, realId }) => Logger.println(`${isLinked ? '*' : ' '} ${name} (${realId})`));
+      }
+    }
   }
 }
 
 async function linkApp (params) {
-  const { alias } = params.options;
+  const { alias, app: appIdOrName } = params.options;
   const [dependency] = params.args;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   await Application.link(ownerId, appId, dependency);
   Logger.println(`App ${dependency.app_id || dependency.app_name} successfully linked`);
 }
 
 async function unlinkApp (params) {
-  const { alias } = params.options;
+  const { alias, app: appIdOrName } = params.options;
   const [dependency] = params.args;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   await Application.unlink(ownerId, appId, dependency);
   Logger.println(`App ${dependency.app_id || dependency.app_name} successfully unlinked`);
 }
 
 async function linkAddon (params) {
-  const { alias } = params.options;
+  const { alias, app: appIdOrName } = params.options;
   const [addon] = params.args;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   await Addon.link(ownerId, appId, addon);
   Logger.println(`Addon ${addon.addon_id || addon.addon_name} successfully linked`);
 }
 
 async function unlinkAddon (params) {
-  const { alias } = params.options;
+  const { alias, app: appIdOrName } = params.options;
   const [addon] = params.args;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   await Addon.unlink(ownerId, appId, addon);
   Logger.println(`Addon ${addon.addon_id || addon.addon_name} successfully unlinked`);

package/src/commands/ssh.js

@@ -2,13 +2,13 @@
 
 const { spawn } = require('child_process');
 
-const AppConfig = require('../models/app_configuration.js');
+const Application = require('../models/application.js');
 const { conf } = require('../models/configuration.js');
 
 async function ssh (params) {
-  const { alias, 'identity-file': identityFile } = params.options;
+  const { alias, app: appIdOrName, 'identity-file': identityFile } = params.options;
 
-  const { appId } = await AppConfig.getAppDetails({ alias });
+  const { appId } = await Application.resolveId(appIdOrName, alias);
   const sshParams = ['-t', conf.SSH_GATEWAY, appId];
   if (identityFile != null) {
     sshParams.push('-i', identityFile);

package/src/commands/status.js

@@ -3,22 +3,49 @@
 const _ = require('lodash');
 const colors = require('colors/safe');
 
-const AppConfig = require('../models/app_configuration.js');
+const Application = require('../models/application.js');
 const Logger = require('../logger.js');
 
 const { get: getApplication, getAllInstances } = require('@clevercloud/client/cjs/api/v2/application.js');
 const { sendToApi } = require('../models/send-to-api.js');
 
-function displayGroupInfo (instances, commit) {
-  return `(${displayFlavors(instances)},  Commit: ${commit || 'N/A'})`;
+async function status (params) {
+  const { alias, app: appIdOrName, format } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+  const instances = await getAllInstances({ id: ownerId, appId }).then(sendToApi);
+  const app = await getApplication({ id: ownerId, appId }).then(sendToApi);
+
+  const status = computeStatus(instances, app);
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(status);
+      break;
+    }
+    case 'human':
+    default: {
+      const statusMessage = status.status === 'running'
+        ? `${colors.bold.green('running')} ${displayInstances(status.instances, status.commit)}`
+        : colors.bold.red('stopped');
+
+      Logger.println(`${status.name}: ${statusMessage}`);
+      Logger.println(`Executed as: ${colors.bold(status.lifetime)}`);
+      if (status.deploymentInProgress) {
+        Logger.println(`Deployment in progress ${displayInstances(status.deploymentInProgress.instances, status.deploymentInProgress.commit)}`);
+      }
+      Logger.println();
+      Logger.println('Scalability:');
+      Logger.println(`  Auto scalability: ${status.scalability.enabled ? colors.green('enabled') : colors.red('disabled')}`);
+      Logger.println(`  Scalers: ${colors.bold(formatScalability(status.scalability.horizontal))}`);
+      Logger.println(`  Sizes: ${colors.bold(formatScalability(status.scalability.vertical))}`);
+      Logger.println(`  Dedicated build: ${status.separateBuild ? colors.bold(status.buildFlavor) : colors.red('disabled')}`);
+    }
+  }
 }
 
-function displayFlavors (instances) {
-  return _(instances)
-    .groupBy((i) => i.flavor.name)
-    .map((instances, flavorName) => `${instances.length}*${flavorName}`)
-    .value()
-    .join(', ');
+function displayInstances (instances, commit) {
+  return `(${instances.map((instance) => `${instance.count}*${instance.flavor}`)},  Commit: ${commit || 'N/A'})`;
 }
 
 function computeStatus (instances, app) {
@@ -30,50 +57,49 @@ function computeStatus (instances, app) {
   const isDeploying = !_.isEmpty(deployingInstances);
   const deployingCommit = _(deployingInstances).map('commit').head();
 
-  const statusMessage = isUp
-    ? `${colors.bold.green('running')} ${displayGroupInfo(upInstances, upCommit)}`
-    : colors.bold.red('stopped');
-
-  const statusLine = `${app.name}: ${statusMessage}`;
-  const taskLine = `Executed as: ${colors.bold(app.instance.lifetime)}`;
-  const deploymentLine = isDeploying
-    ? `Deployment in progress ${displayGroupInfo(deployingInstances, deployingCommit)}`
-    : '';
-
-  return [statusLine, taskLine, deploymentLine].join('\n');
-}
-
-function displayScalability (app) {
-
   const { minFlavor, maxFlavor, minInstances, maxInstances } = app.instance;
 
-  const vertical = (minFlavor.name === maxFlavor.name)
-    ? minFlavor.name
-    : `${minFlavor.name} to ${maxFlavor.name}`;
-
-  const horizontal = (minInstances === maxInstances)
-    ? minInstances
-    : `${minInstances} to ${maxInstances}`;
-
-  const enabled = (minFlavor.name !== maxFlavor.name)
+  const scalabilityEnabled = (minFlavor.name !== maxFlavor.name)
     || (minInstances !== maxInstances);
 
-  return `Scalability:
-  Auto scalability: ${enabled ? colors.green('enabled') : colors.red('disabled')}
-  Scalers: ${colors.bold(horizontal)}
-  Sizes: ${colors.bold(vertical)}
-  Dedicated build: ${app.separateBuild ? colors.bold(app.buildFlavor.name) : colors.red('disabled')}`;
+  const status = {
+    id: app.id,
+    name: app.name,
+    lifetime: app.instance.lifetime,
+    status: isUp ? 'running' : 'stopped',
+    commit: upCommit,
+    instances: groupInstances(upInstances),
+    scalability: {
+      enabled: scalabilityEnabled,
+      vertical: { min: minFlavor.name, max: maxFlavor.name },
+      horizontal: { min: minInstances, max: maxInstances },
+    },
+    separateBuild: app.separateBuild,
+    buildFlavor: app.buildFlavor.name,
+  };
+
+  if (isDeploying) {
+    status.deploymentInProgress = {
+      commit: deployingCommit,
+      instances: groupInstances(deployingInstances),
+    };
+  }
+
+  return status;
 }
 
-async function status (params) {
-  const { alias } = params.options;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
-
-  const instances = await getAllInstances({ id: ownerId, appId }).then(sendToApi);
-  const app = await getApplication({ id: ownerId, appId }).then(sendToApi);
+function formatScalability ({ min, max }) {
+  return (min === max) ? min : `${min} to ${max}`;
+}
 
-  Logger.println(computeStatus(instances, app));
-  Logger.println(displayScalability(app));
+function groupInstances (instances) {
+  return _(instances)
+    .groupBy((i) => i.flavor.name)
+    .map((instances, flavorName) => ({
+      flavor: flavorName,
+      count: instances.length,
+    }))
+    .value();
 }
 
 module.exports = { status };

package/src/commands/stop.js

@@ -1,13 +1,13 @@
 'use strict';
 
-const AppConfig = require('../models/app_configuration.js');
+const Application = require('../models/application.js');
 const application = require('@clevercloud/client/cjs/api/v2/application.js');
 const Logger = require('../logger.js');
 const { sendToApi } = require('../models/send-to-api.js');
 
 async function stop (params) {
-  const { alias } = params.options;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { alias, app: appIdOrName } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   await application.undeploy({ id: ownerId, appId }).then(sendToApi);
   Logger.println('App successfully stopped!');