clever-tools 4.4.0 → 4.5.0

package/src/models/addon.js

@@ -10,7 +10,6 @@ import { getAllLinkedAddons, linkAddon, unlinkAddon } from '@clevercloud/client/
 import { getAllAddonProviders } from '@clevercloud/client/esm/api/v2/product.js';
 import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
 import { getAddonProvider } from '@clevercloud/client/esm/api/v4/addon-providers.js';
-import cliparse from 'cliparse';
 import { confirm } from '../lib/prompts.js';
 import { Logger } from '../logger.js';
 import { resolveOwnerId } from './ids-resolver.js';
@@ -220,28 +219,12 @@ export async function rename(ownerId, addon, name) {
 }
 
 export function completeRegion() {
-  return cliparse.autocomplete.words(['par', 'mtl']);
+  return ['par', 'mtl'];
 }
 
 // TODO: We need to fix this
 export function completePlan() {
-  return cliparse.autocomplete.words(['dev', 's', 'm', 'l', 'xl', 'xxl']);
-}
-
-export async function findById(addonId) {
-  const { user, organisations } = await getSummary({}).then(sendToApi);
-  for (const orga of [user, ...organisations]) {
-    for (const simpleAddon of orga.addons) {
-      if (simpleAddon.id === addonId) {
-        const addon = await getAddon({ id: orga.id, addonId }).then(sendToApi);
-        return {
-          ...addon,
-          orgaId: orga.id,
-        };
-      }
-    }
-  }
-  throw new Error(`Could not find add-on with ID: ${addonId}`);
+  return ['dev', 's', 'm', 'l', 'xl', 'xxl'];
 }
 
 export async function findByName(addonName) {

package/src/models/app_configuration.js

@@ -131,27 +131,6 @@ function findDefaultApp(config) {
   );
 }
 
-async function getAppDetailsForId(appId) {
-  const config = await loadApplicationConf();
-
-  if (_.isEmpty(config.apps)) {
-    throw new Error('There is no linked or targeted application. Use `--app` option or `clever link` command.');
-  }
-
-  const [appById, secondAppById] = _.filter(config.apps, { app_id: appId });
-  if (appById == null) {
-    throw new Error(`There are no applications matching id '${appId}'`);
-  }
-  if (secondAppById != null) {
-    throw new Error(
-      `There are several applications matching id '${appId}'.` +
-        'This should not happen, your `.clever.json` should be fixed.',
-    );
-  }
-
-  return appById;
-}
-
 export async function getAppDetails({ alias }) {
   const config = await loadApplicationConf();
   const app = findApp(config, alias);
@@ -165,15 +144,6 @@ export async function getAppDetails({ alias }) {
   };
 }
 
-export async function getMostNaturalName(appId) {
-  try {
-    const details = await getAppDetailsForId(appId);
-    return details.alias || details.name || appId;
-  } catch {
-    return appId;
-  }
-}
-
 function persistConfig(modifiedConfig) {
   const jsonContents = JSON.stringify(modifiedConfig, null, 2);
   return fs.writeFile(conf.APP_CONFIGURATION_FILE, jsonContents);

package/src/models/application.js

@@ -11,7 +11,6 @@ import {
 } from '@clevercloud/client/esm/api/v2/application.js';
 import { getAvailableInstances } from '@clevercloud/client/esm/api/v2/product.js';
 import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
-import cliparse from 'cliparse';
 import _ from 'lodash';
 import { confirmAnswer } from '../lib/prompts.js';
 import { styleText } from '../lib/style-text.js';
@@ -23,7 +22,7 @@ import { sendToApi } from './send-to-api.js';
 import * as User from './user.js';
 
 export function listAvailableTypes() {
-  return cliparse.autocomplete.words([
+  return [
     'docker',
     'elixir',
     'frankenphp',
@@ -46,17 +45,17 @@ export function listAvailableTypes() {
     'static-apache',
     'v',
     'war',
-  ]);
+  ];
 }
 
 export const AVAILABLE_ZONES = ['par', 'parhds', 'grahds', 'rbx', 'rbxhds', 'scw', 'ldn', 'mtl', 'sgp', 'syd', 'wsw'];
 
 export function listAvailableZones() {
-  return cliparse.autocomplete.words(AVAILABLE_ZONES);
+  return AVAILABLE_ZONES;
 }
 
 export function listAvailableAliases() {
-  return AppConfiguration.loadApplicationConf().then(({ apps }) => cliparse.autocomplete.words(_.map(apps, 'alias')));
+  return AppConfiguration.loadApplicationConf().then(({ apps }) => _.map(apps, 'alias'));
 }
 
 export function listAvailableFlavors() {

package/src/models/application_configuration.js

@@ -1,4 +1,3 @@
-import cliparse from 'cliparse';
 import dedent from 'dedent';
 import { Logger } from '../logger.js';
 
@@ -80,29 +79,12 @@ export function parse(config, value) {
   }
 }
 
-export function getUpdateOptions() {
-  return CONFIG_KEYS.map((config) => getConfigOptions(config)).reduce((a, b) => [...a, ...b], []);
-}
-
-function getConfigOptions(config) {
-  switch (config.kind) {
-    case 'bool':
-    case 'inverted-bool':
-    case 'force-https':
-    case 'task': {
-      return [
-        cliparse.flag(`enable-${config.id}`, { description: `Enable ${config.id}` }),
-        cliparse.flag(`disable-${config.id}`, { description: `Disable ${config.id}` }),
-      ];
-    }
-    default: {
-      return [cliparse.option(`${config.id}`, { description: `Set ${config.id}` })];
-    }
-  }
-}
-
 export function parseOptions(options) {
-  const newOptions = CONFIG_KEYS.map((config) => parseConfigOption(config, options)).filter((a) => a != null);
+  const newOptions = CONFIG_KEYS.map((config) => {
+    return parseConfigOption(config, options);
+  }).filter((a) => {
+    return a != null && a[1] != null;
+  });
   return Object.fromEntries(newOptions);
 }
 

package/src/models/domain.js

@@ -1,11 +1,15 @@
-import { getAllDomains, getFavouriteDomain } from '@clevercloud/client/esm/api/v2/application.js';
+import {
+  getAllDomains,
+  getFavouriteDomain as getFavouriteDomainWithError,
+} from '@clevercloud/client/esm/api/v2/application.js';
 import _ from 'lodash';
+import { parse as parseDomain } from 'tldts';
 import { Logger } from '../logger.js';
 import { sendToApi } from './send-to-api.js';
 
 export async function getBest(appId, orgaId) {
   Logger.debug('Trying to get the favourite vhost for ' + appId);
-  return getFavouriteDomain({ id: orgaId, appId })
+  return getFavouriteDomainWithError({ id: orgaId, appId })
     .then(sendToApi)
     .catch(async (e) => {
       if (e.response.status !== 404) {
@@ -35,3 +39,31 @@ export function selectBest(vhosts) {
   });
   return customVhost || withoutDefaultDomain || vhosts[0];
 }
+
+export function getFavouriteDomain({ ownerId, appId }) {
+  return getFavouriteDomainWithError({ id: ownerId, appId })
+    .then(sendToApi)
+    .then(({ fqdn }) => fqdn)
+    .catch((error) => {
+      if (error.id === 4021) {
+        // No favourite vhost
+        return null;
+      }
+      throw error;
+    });
+}
+
+export function getDomainObject(domainWithPathPrefix, favouriteDomain) {
+  const parsed = parseDomain(domainWithPathPrefix, { validateHostname: false });
+  return {
+    domainWithPathPrefix,
+    domain: parsed.domain,
+    domainWithoutSuffix: parsed.domainWithoutSuffix,
+    hostname: parsed.hostname,
+    publicSuffix: parsed.publicSuffix,
+    subdomain: parsed.subdomain,
+    isApex: parsed.subdomain === '',
+    pathPrefix: new URL('https://' + domainWithPathPrefix).pathname,
+    isFavourite: domainWithPathPrefix === favouriteDomain,
+  };
+}

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

@@ -1,17 +1,8 @@
-import { styleText } from '../lib/style-text.js';
-import { Logger } from '../logger.js';
-
 export 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(
-      styleText(
-        '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;

package/src/models/git.js

@@ -1,4 +1,3 @@
-import cliparse from 'cliparse';
 import * as git from 'isomorphic-git';
 import _ from 'lodash';
 import fs from 'node:fs';
@@ -111,9 +110,7 @@ export async function push(remoteUrl, branchRefspec, force) {
 }
 
 export function completeBranches() {
-  return getRepo()
-    .then((repo) => git.listBranches(repo))
-    .then(cliparse.autocomplete.words);
+  return getRepo().then((repo) => git.listBranches(repo));
 }
 
 export async function isShallow() {

package/src/models/log-v4.js

@@ -133,12 +133,23 @@ export async function watchDeploymentAndDisplayLogs(options) {
     logsStream.close(quiet ? 'quiet' : 'follow');
   }
 
+  // deploymentEnded can be undefined if deferred resolved (e.g., stream closed via SIGINT)
+  if (deploymentEnded == null) {
+    return;
+  }
+
   if (deploymentEnded.state === 'OK') {
-    const favouriteDomain = await getBest(appId, ownerId);
     Logger.println('');
-    Logger.println(
-      `${styleText(['bold', 'green'], '✓ Access your application:')} ${styleText(['underline', 'bold'], `https://${favouriteDomain.fqdn}`)}`,
-    );
+
+    // There can be applications without any domain, so we don't fail if we can't get one
+    const favouriteDomain = await getBest(appId, ownerId).catch(() => null);
+
+    if (favouriteDomain) {
+      Logger.println(
+        `${styleText(['bold', 'green'], '✓ Access your application:')} ${styleText(['underline', 'bold'], `https://${favouriteDomain.fqdn}`)}`,
+      );
+    }
+
     Logger.println(
       `${styleText(['bold', 'blue'], '→ Manage your application:')} ${styleText(['underline', 'bold'], `${conf.GOTO_URL}/${appId}`)}`,
     );

package/src/models/log.js

@@ -133,6 +133,11 @@ export async function watchDeploymentAndDisplayLogs({
     logsStream.close();
   }
 
+  // deploymentEnded can be undefined if deferred resolved (e.g., stream closed via SIGINT)
+  if (deploymentEnded == null) {
+    return;
+  }
+
   if (deploymentEnded.state === 'OK') {
     Logger.println(styleText(['bold', 'green'], 'Deployment successful'));
   } else if (deploymentEnded.state === 'CANCELLED') {

package/src/models/namespaces.js

@@ -1,5 +1,4 @@
 import { getNamespaces as getTcpRedirNamespaces } from '@clevercloud/client/esm/api/v2/organisation.js';
-import cliparse from 'cliparse';
 import * as Application from './application.js';
 import { sendToApi } from './send-to-api.js';
 
@@ -11,5 +10,5 @@ export 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(cliparse.autocomplete.words);
+  return getNamespaces(ownerId);
 }

package/src/models/notification.js

@@ -1,15 +1,9 @@
-import cliparse from 'cliparse';
 import * as AppConfig from './app_configuration.js';
 import * as Organisation from './organisation.js';
 import * as User from './user.js';
 
 export function listMetaEvents() {
-  return cliparse.autocomplete.words([
-    'META_SERVICE_LIFECYCLE',
-    'META_DEPLOYMENT_RESULT',
-    'META_SERVICE_MANAGEMENT',
-    'META_CREDITS',
-  ]);
+  return ['META_SERVICE_LIFECYCLE', 'META_DEPLOYMENT_RESULT', 'META_SERVICE_MANAGEMENT', 'META_CREDITS'];
 }
 
 export function getOrgaIdOrUserId(orgIdOrName) {

package/src/parsers.js

@@ -1,4 +1,3 @@
-import cliparse from 'cliparse';
 import ISO8601 from 'iso8601-duration';
 import * as Application from './models/application.js';
 import { NG_MEMBER_PREFIXES } from './models/ng.js';
@@ -9,92 +8,63 @@ export function addonOptions(options) {
   const optionsArray = typeof options === 'string' ? [options] : options;
   for (const option of optionsArray) {
     if (!option.match(addonOptionsRegex)) {
-      return cliparse.parsers.error('Invalid option: ' + option);
+      throw new Error('Invalid option: ' + option);
     }
   }
-  return cliparse.parsers.success(optionsArray.join(','));
+  return optionsArray.join(',');
 }
 
 export function flavor(flavor) {
   const flavors = Application.listAvailableFlavors();
   if (flavors.includes(flavor)) {
-    return cliparse.parsers.success(flavor);
+    return flavor;
   }
-  return cliparse.parsers.error('Invalid value: ' + flavor);
+  throw new Error('Invalid value: ' + flavor);
 }
 
 export function buildFlavor(flavorOrDisabled) {
   if (flavorOrDisabled === 'disabled') {
-    return cliparse.parsers.success(flavorOrDisabled);
+    return flavorOrDisabled;
   }
   return flavor(flavorOrDisabled);
 }
 
-export function instances(instances) {
-  const parsedInstances = parseInt(instances, 10);
-  if (isNaN(parsedInstances)) {
-    return cliparse.parsers.error('Invalid number: ' + instances);
-  }
-  if (parsedInstances < 1 || parsedInstances > 20) {
-    return cliparse.parsers.error('The number of instances must be between 1 and 20');
-  }
-  return cliparse.parsers.success(parsedInstances);
-}
-
 export function date(dateString) {
   const date = new Date(dateString);
   if (isNaN(dateString) && !isNaN(date.getTime())) {
-    return cliparse.parsers.success(date);
+    return date;
   }
 
-  const duration = durationInSeconds(dateString);
-  if (duration.success) {
-    return cliparse.parsers.success(new Date(Date.now() - duration.success * 1000));
-  }
-
-  return duration;
+  const seconds = durationInSeconds(dateString);
+  return new Date(Date.now() - seconds * 1000);
 }
 
 export function futureDateOrDuration(dateString) {
   const date = new Date(dateString);
   if (isNaN(dateString) && !isNaN(date.getTime())) {
-    return cliparse.parsers.success(date);
-  }
-
-  const duration = durationInSeconds(dateString);
-  if (duration.success) {
-    return cliparse.parsers.success(new Date(Date.now() + duration.success * 1000));
+    return date;
   }
 
-  return duration;
-}
-
-// This simple regex is enough for our use cases
-const emailRegex = /^\S+@\S+\.\S+$/g;
-
-export function email(string) {
-  if (string.match(emailRegex)) {
-    return cliparse.parsers.success(string);
-  }
-  return cliparse.parsers.error('Invalid email');
+  const seconds = durationInSeconds(dateString);
+  return new Date(Date.now() + seconds * 1000);
 }
 
 const appIdRegex = /^app_[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
 export function appIdOrName(string) {
   if (string.match(appIdRegex)) {
-    return cliparse.parsers.success({ app_id: string });
+    return { app_id: string };
   }
-  return cliparse.parsers.success({ app_name: string });
+  return { app_name: string };
 }
 
 const orgaIdRegex = /^(user_|orga_)[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
 export function orgaIdOrName(string) {
   if (string.match(orgaIdRegex)) {
-    return cliparse.parsers.success({ orga_id: string });
+    return { orga_id: string };
   }
-  return cliparse.parsers.success({ orga_name: string });
+  return { orga_name: string };
 }
 
 const addonIdRegex = /^addon_[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -104,31 +74,16 @@ const ulidRegex = /^(kubernetes)_[0-9A-HJ-NP-TV-Z]{26}$/i;
 
 export function addonIdOrName(string) {
   if (string.match(addonIdRegex)) {
-    return cliparse.parsers.success({ addon_id: string });
+    return { addon_id: string };
   }
   if (string.match(operatorIdRegex) || string.match(ulidRegex)) {
-    return cliparse.parsers.success({ operator_id: string });
+    return { operator_id: string };
   }
-  return cliparse.parsers.success({ addon_name: string });
+  return { addon_name: string };
 }
 
 export function commaSeparated(string) {
-  return cliparse.parsers.success(string.split(','));
-}
-
-export function integer(string) {
-  const integer = parseInt(string);
-  if (isNaN(integer)) {
-    return cliparse.parsers.error('Invalid number: ' + string);
-  }
-  return cliparse.parsers.success(integer);
-}
-
-export function nonEmptyString(string) {
-  if (typeof string !== 'string' || string === '') {
-    return cliparse.parsers.error('Invalid string, it should not be empty');
-  }
-  return cliparse.parsers.success(string);
+  return string.split(',');
 }
 
 // /^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/i;
@@ -136,41 +91,20 @@ const tagRegex = /^[^,\s]+$/;
 
 export function tag(string) {
   if (string.match(tagRegex)) {
-    return cliparse.parsers.success(string);
+    return string;
   }
-  return cliparse.parsers.error(`Invalid tag '${string}'. Should match ${tagRegex}`);
+  throw new Error(`Invalid tag '${string}'. Should match ${tagRegex}`);
 }
 
 export function tags(string) {
   if (String(string).length === 0) {
-    return cliparse.parsers.success([]);
+    return [];
   }
   const tags = String(string).split(',');
   for (const current of tags) {
-    if (tag(current).error) {
-      return cliparse.parsers.error(`Invalid tag '${current}'. Should match \`${tagRegex}\``);
-    }
-  }
-  return cliparse.parsers.success(tags);
-}
-
-export const ipAddressRegex =
-  /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])$/;
-
-export function ipAddress(string) {
-  if (string.match(ipAddressRegex)) {
-    return cliparse.parsers.success(string);
+    tag(current); // will throw if invalid
   }
-  return cliparse.parsers.error(`Invalid IP address '${string}'. Should match ${ipAddressRegex}`);
-}
-
-export const portNumberRegex = /^\d{1,5}$/;
-
-export function portNumber(number) {
-  if (String(number).match(portNumberRegex)) {
-    return cliparse.parsers.success(number);
-  }
-  return cliparse.parsers.error(`Invalid port number '${number}'. Should match ${portNumberRegex}`);
+  return tags;
 }
 
 /**
@@ -180,29 +114,25 @@ export function portNumber(number) {
  * @returns {number} number of seconds
  */
 export function durationInSeconds(durationStr = '') {
-  const failed = cliparse.parsers.error(
-    `Invalid duration: "${durationStr}", expect (IS0 8601 duration / a "1h, 1m, 30s" like duration / a positive number in seconds)`,
-  );
+  const errorMessage = `Invalid duration: "${durationStr}", expect (IS0 8601 duration / a "1h, 1m, 30s" like duration / a positive number in seconds)`;
 
   if (durationStr.startsWith('P')) {
     try {
       const d = ISO8601.parse(durationStr);
-      return cliparse.parsers.success(ISO8601.toSeconds(d));
+      return ISO8601.toSeconds(d);
     } catch {
-      return failed;
+      throw new Error(errorMessage);
     }
   }
 
   try {
-    const durationInSeconds = parseSimpleDuration(durationStr);
-    return cliparse.parsers.success(durationInSeconds);
+    return parseSimpleDuration(durationStr);
   } catch {
     const n = Number.parseInt(durationStr);
     if (isNaN(n) || n < 0) {
-      return failed;
+      throw new Error(errorMessage);
     }
-
-    return cliparse.parsers.success(n);
+    return n;
   }
 }
 
@@ -230,18 +160,10 @@ function parseSimpleDuration(durationStr) {
 // Network Groups parsers
 export function ngResourceType(string) {
   if (string.startsWith('ng_')) {
-    return cliparse.parsers.success({ ngId: string });
+    return { ngId: string };
   }
   if (Object.keys(NG_MEMBER_PREFIXES).some((prefix) => string.startsWith(prefix))) {
-    return cliparse.parsers.success({ memberId: string });
-  }
-  return cliparse.parsers.success({ ngResourceLabel: string });
-}
-
-export function ngValidType(string) {
-  if (string === 'NetworkGroup' || string === 'Member' || string === 'CleverPeer' || string === 'ExternalPeer') {
-    return cliparse.parsers.success(string);
-  } else {
-    return cliparse.parsers.error(`Invalid Network Group resource type: ${string}`);
+    return { memberId: string };
   }
+  return { ngResourceLabel: string };
 }

package/src/command-options.js

@@ -1,55 +0,0 @@
-import cliparse from 'cliparse';
-
-export function getOutputFormatOption(formats = []) {
-  const availableFormats = ['human', 'json', ...formats];
-  return cliparse.option('format', {
-    aliases: ['F'],
-    metavar: 'format',
-    parser: (format) => {
-      return availableFormats.includes(format)
-        ? cliparse.parsers.success(format)
-        : cliparse.parsers.error('The output format must be one of ' + availableFormats.join(', '));
-    },
-    default: 'human',
-    description: `Output format (${availableFormats.join(', ')})`,
-    complete() {
-      return cliparse.autocomplete.words(availableFormats);
-    },
-  });
-}
-
-export function getSameCommitPolicyOption() {
-  const availablePolicies = ['error', 'ignore', 'restart', 'rebuild'];
-  return cliparse.option('same-commit-policy', {
-    aliases: ['p'],
-    metavar: 'policy',
-    parser: (policy) => {
-      return availablePolicies.includes(policy)
-        ? cliparse.parsers.success(policy)
-        : cliparse.parsers.error(`the policy must be one of ${availablePolicies.join(', ')}`);
-    },
-    default: 'error',
-    description: `What to do when local and remote commit are identical (${availablePolicies.join(', ')})`,
-    complete() {
-      return cliparse.autocomplete.words(availablePolicies);
-    },
-  });
-}
-
-export function getExitOnOption() {
-  const availableExitOn = ['deploy-start', 'deploy-end', 'never'];
-  return cliparse.option('exit-on', {
-    aliases: ['e'],
-    metavar: 'step',
-    parser: (exitOnStrategy) => {
-      return availableExitOn.includes(exitOnStrategy)
-        ? cliparse.parsers.success(exitOnStrategy)
-        : cliparse.parsers.error(`The exit-on strategy must be one of ${availableExitOn.join(', ')}`);
-    },
-    default: 'deploy-end',
-    description: `Step at which the logs streaming is ended, steps are: ${availableExitOn.join(', ')}`,
-    complete() {
-      return cliparse.autocomplete.words(availableExitOn);
-    },
-  });
-}

package/src/command-promise-handler.js

@@ -1,16 +0,0 @@
-import semver from 'semver';
-import pkg from '../package.json' with { type: 'json' };
-import { Logger } from './logger.js';
-
-export function handleCommandPromise(promise) {
-  promise.catch((error) => {
-    Logger.error(error);
-    const semverIsOk = semver.satisfies(process.version, pkg.engines.node);
-    if (!semverIsOk) {
-      Logger.warn(
-        `You are using node ${process.version}, some of our commands require node ${pkg.engines.node}. The error may be caused by this.`,
-      );
-    }
-    process.exit(1);
-  });
-}