clever-tools 4.4.1 → 4.5.0

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,6 +133,11 @@ 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') {
     Logger.println('');
 

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);
-  }
-
-  const duration = durationInSeconds(dateString);
-  if (duration.success) {
-    return cliparse.parsers.success(new Date(Date.now() - duration.success * 1000));
+    return date;
   }
 
-  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);
+    return date;
   }
 
-  const duration = durationInSeconds(dateString);
-  if (duration.success) {
-    return cliparse.parsers.success(new Date(Date.now() + duration.success * 1000));
-  }
-
-  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,22 +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}\``);
-    }
+    tag(current); // will throw if invalid
   }
-  return cliparse.parsers.success(tags);
+  return tags;
 }
 
 /**
@@ -161,29 +114,25 @@ export function tags(string) {
  * @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;
   }
 }
 
@@ -211,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);
-  });
-}

package/src/commands/accesslogs.js

@@ -1,138 +0,0 @@
-import { ApplicationAccessLogStream } from '@clevercloud/client/esm/streams/access-logs.js';
-import { formatTable } from '../format-table.js';
-import { styleText } from '../lib/style-text.js';
-import { Logger } from '../logger.js';
-import * as Application from '../models/application.js';
-import { JsonArray } from '../models/json-array.js';
-import { getHostAndTokens } from '../models/send-to-api.js';
-import { truncateWithEllipsis } from '../models/utils.js';
-
-// 2000 logs per 100ms maximum
-const THROTTLE_ELEMENTS = 2000;
-const THROTTLE_PER_IN_MILLISECONDS = 100;
-const CITY_MAX_LENGTH = 20;
-
-export async function accessLogs(params) {
-  // TODO: drop when add-ons are supported in API
-  if (params.options.addon) {
-    throw new Error('Access Logs are not available for add-ons yet');
-  }
-
-  const { apiHost, tokens } = await getHostAndTokens();
-  const { alias, app: appIdOrName, format, before: until, after: since } = params.options;
-  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-
-  const stream = new ApplicationAccessLogStream({
-    apiHost,
-    tokens,
-    ownerId,
-    appId,
-    since,
-    until,
-    throttleElements: THROTTLE_ELEMENTS,
-    throttlePerInMilliseconds: THROTTLE_PER_IN_MILLISECONDS,
-  });
-
-  if (format === 'human') {
-    Logger.println(styleText('yellow', '/!\\ This feature is in Beta testing phase'));
-  }
-
-  if (format === 'json' && !until) {
-    throw new Error('JSON format only works with a limiting parameter such as `before`');
-  }
-
-  // used for 'json' format
-  const jsonArray = new JsonArray();
-
-  stream
-    .on('open', () => {
-      Logger.debug(styleText('blue', `Logs stream (open) ${JSON.stringify({ appId })}`));
-      if (format === 'json') {
-        jsonArray.open();
-      }
-    })
-    .on('error', (event) => {
-      Logger.debug(styleText('red', `Logs stream (error) ${event.error.message}`));
-    })
-    .onLog((log) => {
-      switch (format) {
-        case 'json':
-          jsonArray.push(log);
-          break;
-        case 'json-stream':
-          Logger.printJson(log);
-          break;
-        case 'human':
-        default:
-          // when the connection is cut too early, or for TCP redirections, we don't have HTTP section
-          if (log.http == null) {
-            break;
-          }
-
-          Logger.println(formatHuman(log));
-          break;
-      }
-    });
-
-  // Properly close the stream
-  process.once('SIGINT', (signal) => stream.close(signal));
-
-  const closeReason = await stream.start();
-
-  if (format === 'json') {
-    jsonArray.close();
-  }
-
-  Logger.debug(`stream closed: ${closeReason?.type}`);
-}
-
-function formatHuman(log) {
-  const { date, http, source } = log;
-  const country = source.countryCode ?? '(unknown)';
-  const hasSourceCity = source.city ?? '';
-
-  return formatTable(
-    [
-      [
-        styleText('grey', date.toISOString(date)),
-        source.ip,
-        `${country}${hasSourceCity ? '/' + truncateWithEllipsis(CITY_MAX_LENGTH, source.city) : ''}`,
-        colorStatusCode(http.response.statusCode),
-        http.request.method.toString().padEnd(4, ' ') + ' ' + http.request.path,
-      ],
-    ],
-    ACCESSLOG_COLUMN_WIDTHS,
-  );
-}
-
-const ACCESSLOG_COLUMN_WIDTHS = [
-  '2024-06-24T08:05:43.880Z',
-  '255.255.255.255',
-  // country / city
-  2 + 1 + CITY_MAX_LENGTH,
-  'XXX',
-  // longest method name
-  'OPTIONS',
-  // path
-];
-
-/**
- * @param {number} code
- * @returns {string}
- */
-function colorStatusCode(code) {
-  const codeString = code.toString();
-  if (code >= 500) {
-    return styleText('red', codeString);
-  }
-  if (code >= 400) {
-    return styleText('yellow', codeString);
-  }
-  if (code >= 300) {
-    return styleText('blue', codeString);
-  }
-  if (code >= 200) {
-    return styleText('green', codeString);
-  }
-  return codeString;
-}