clever-tools 3.6.1 → 3.8.0

package/src/commands/env.js

@@ -1,15 +1,16 @@
 'use strict';
 
-const AppConfig = require('../models/app_configuration.js');
+const Application = require('../models/application.js');
 const Logger = require('../logger.js');
+const colors = require('colors/safe');
 const variables = require('../models/variables.js');
 const { sendToApi } = require('../models/send-to-api.js');
 const { toNameEqualsValueString, validateName } = require('@clevercloud/client/cjs/utils/env-vars.js');
 const application = require('@clevercloud/client/cjs/api/v2/application.js');
 
 async function list (params) {
-  const { alias, 'add-export': addExports } = params.options;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { alias, app: appIdOrName, 'add-export': addExportsOption, format } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   const [envFromApp, envFromAddons, envFromDeps] = await Promise.all([
     application.getAllEnvVars({ id: ownerId, appId }).then(sendToApi),
@@ -17,30 +18,58 @@ async function list (params) {
     application.getAllEnvVarsForDependencies({ id: ownerId, appId }).then(sendToApi),
   ]);
 
-  Logger.println('# Manually set env variables');
-  Logger.println(toNameEqualsValueString(envFromApp, { addExports }));
-
-  envFromAddons.forEach((addon) => {
-    Logger.println('# Addon ' + addon.addon_name);
-    Logger.println(toNameEqualsValueString(addon.env, { addExports }));
-  });
-
-  envFromDeps.forEach((dep) => {
-    Logger.println('# Dependency ' + dep.app_name);
-    Logger.println(toNameEqualsValueString(dep.env, { addExports }));
-  });
-};
+  switch (format) {
+    case 'json': {
+      Logger.printJson({
+        env: envFromApp,
+        fromAddons: envFromAddons.map((addon) => ({
+          addonId: addon.addon_id,
+          addonName: addon.addon_name,
+          env: addon.env,
+        })),
+        fromDependencies: envFromDeps.map((dep) => ({
+          addonId: dep.app_id,
+          addonName: dep.app_name,
+          env: dep.env,
+        })),
+      });
+      break;
+    }
+    case 'shell':
+    case 'human':
+    default: {
+      if (addExportsOption) {
+        Logger.println(colors.yellow('`--add-export` option is deprecated. Use `--format shell` instead.'));
+      }
+
+      const addExports = addExportsOption || format === 'shell';
+
+      Logger.println('# Manually set env variables');
+      Logger.println(toNameEqualsValueString(envFromApp, { addExports }));
+
+      envFromAddons.forEach((addon) => {
+        Logger.println('# Addon ' + addon.addon_name);
+        Logger.println(toNameEqualsValueString(addon.env, { addExports }));
+      });
+
+      envFromDeps.forEach((dep) => {
+        Logger.println('# Dependency ' + dep.app_name);
+        Logger.println(toNameEqualsValueString(dep.env, { addExports }));
+      });
+    }
+  }
+}
 
 async function set (params) {
   const [envName, value] = params.args;
-  const { alias } = params.options;
+  const { alias, app: appIdOrName } = params.options;
 
   const nameIsValid = validateName(envName);
   if (!nameIsValid) {
     throw new Error(`Environment variable name ${envName} is invalid`);
   }
 
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   await application.updateEnvVar({ id: ownerId, appId, envName }, { value }).then(sendToApi);
 
@@ -49,8 +78,8 @@ async function set (params) {
 
 async function rm (params) {
   const [envName] = 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);
 
   await application.removeEnvVar({ id: ownerId, appId, envName }).then(sendToApi);
 
@@ -58,9 +87,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 envVars = await variables.readVariablesFromStdin(format);
   await application.updateAllEnvVars({ id: ownerId, appId }, envVars).then(sendToApi);
@@ -70,7 +99,7 @@ async function importEnv (params) {
 
 async function importVarsFromLocalEnv (params) {
   const [envNames] = params.args;
-  const { alias } = params.options;
+  const { alias, app: appIdOrName } = params.options;
 
   for (const envName of envNames) {
     const nameIsValid = validateName(envName);
@@ -79,7 +108,7 @@ async function importVarsFromLocalEnv (params) {
     }
   }
 
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   for (const envName of envNames) {
     const value = process.env[envName] || '';

package/src/commands/logs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const AppConfig = require('../models/app_configuration.js');
+const Application = require('../models/application.js');
 const LogV2 = require('../models/log.js');
 const Log = require('../models/log-v4.js');
 const Logger = require('../logger.js');
@@ -9,7 +9,7 @@ const colors = require('colors/safe');
 const { resolveAddonId } = require('../models/ids-resolver.js');
 
 async function appLogs (params) {
-  const { alias, addon: addonIdOrRealId, after: since, before: until, search, 'deployment-id': deploymentId, format } = params.options;
+  const { alias, app: appIdOrName, addon: addonIdOrRealId, after: since, before: until, search, 'deployment-id': deploymentId, format } = params.options;
 
   // ignore --search ""
   const filter = (search !== '') ? search : null;
@@ -27,7 +27,7 @@ async function appLogs (params) {
     return LogV2.displayLogs({ appAddonId: addonId, since, until, filter, deploymentId });
   }
 
-  const { appId, ownerId } = await AppConfig.getAppDetails({ alias });
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   if (isForHuman) {
     Logger.println(colors.blue('Waiting for application logs…'));

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);