clever-tools 3.14.0 → 4.0.0

package/src/commands/activity.js

@@ -1,43 +1,58 @@
-import colors from 'colors/safe.js';
-import moment from 'moment';
+import { styleText } from 'node:util';
 
-import * as Activity from '../models/activity.js';
+import { EventsStream } from '@clevercloud/client/esm/streams/events.js';
 import { formatTable } from '../format-table.js';
 import { Logger } from '../logger.js';
-import { Deferred } from '../models/utils.js';
-import { EventsStream } from '@clevercloud/client/esm/streams/events.node.js';
-import { getHostAndTokens } from '../models/send-to-api.js';
+import * as Activity from '../models/activity.js';
 import * as Application from '../models/application.js';
+import { getHostAndTokens } from '../models/send-to-api.js';
+import { Deferred } from '../models/utils.js';
+
+const dtf = new Intl.DateTimeFormat('en', {
+  year: 'numeric',
+  month: '2-digit',
+  day: '2-digit',
+  hour: '2-digit',
+  minute: '2-digit',
+  second: '2-digit',
+  hour12: false,
+  timeZoneName: 'longOffset',
+});
+
+function formatDate(date) {
+  const d = Object.fromEntries(dtf.formatToParts(date).map((p) => [p.type, p.value]));
+  return `${d.year}-${d.month}-${d.day}T${d.hour}:${d.minute}:${d.second}${d.timeZoneName.replace('GMT', '')}`;
+}
 
-function getColoredState (state, isLast) {
+function getColoredState(state, isLast) {
   if (state === 'OK') {
-    return colors.bold.green(state);
+    return styleText(['bold', 'green'], state);
   }
   if (state === 'FAIL' || state === 'CANCELLED') {
-    return colors.bold.red(state);
+    return styleText(['bold', 'red'], state);
   }
   if (state === 'WIP' && !isLast) {
-    return colors.bold.red('FAIL');
+    return styleText(['bold', 'red'], 'FAIL');
   }
   if (state === 'WIP' && isLast) {
-    return colors.bold.blue('IN PROGRESS');
+    return styleText(['bold', 'blue'], 'IN PROGRESS');
   }
   Logger.warn(`Unknown deployment state: ${state}`);
   return 'UNKNOWN';
 }
 
 // We use examples of maximum width text to have a clean display
-const formatActivityTable = formatTable([
-  moment().format(),
+const ACTIVITY_TABLE_COLUMN_WIDTHS = [
+  formatDate(Date.now()),
   47,
   'IN PROGRESS',
   'downscale',
   // a git commit id is 8 chars long
   8,
   0,
-]);
+];
 
-function convertEventToJson (event) {
+function convertEventToJson(event) {
   return {
     uuid: event.uuid,
     date: event.date,
@@ -48,27 +63,30 @@ function convertEventToJson (event) {
   };
 }
 
-function formatActivityLine (event) {
-  return formatActivityTable([
+function formatActivityLine(event) {
+  return formatTable(
     [
-      moment(event.date).format(),
-      event.uuid,
-      getColoredState(event.state, event.isLast),
-      event.action,
-      event?.commit?.substring(0, 8) ?? 'N/A',
-      event.cause,
+      [
+        formatDate(event.date),
+        event.uuid,
+        getColoredState(event.state, event.isLast),
+        event.action,
+        event?.commit?.substring(0, 8) ?? 'N/A',
+        event.cause,
+      ],
     ],
-  ]);
+    ACTIVITY_TABLE_COLUMN_WIDTHS,
+  );
 }
 
-function isTemporaryEvent (ev) {
+function isTemporaryEvent(ev) {
   if (ev == null) {
     return false;
   }
   return (ev.state === 'WIP' && ev.isLast) || ev.state === 'CANCELLED';
 }
 
-function clearPreviousLine () {
+function clearPreviousLine() {
   if (process.stdout.isTTY) {
     process.stdout.moveCursor(0, -1);
     process.stdout.cursorTo(0);
@@ -76,7 +94,7 @@ function clearPreviousLine () {
   }
 }
 
-function handleEvent (previousEvent, event, handler) {
+function handleEvent(previousEvent, event, handler) {
   if (isTemporaryEvent(previousEvent)) {
     handler.pop();
   }
@@ -86,21 +104,24 @@ function handleEvent (previousEvent, event, handler) {
   return event;
 }
 
-function onEvent (previousEvent, newEvent, handler) {
-  const { event, date, data: { uuid, state, action, commit, cause } } = newEvent;
+function onEvent(previousEvent, newEvent, handler) {
+  const {
+    event,
+    date,
+    data: { uuid, state, action, commit, cause },
+  } = newEvent;
   if (event !== 'DEPLOYMENT_ACTION_BEGIN' && event !== 'DEPLOYMENT_ACTION_END') {
     return previousEvent;
   }
   return handleEvent(previousEvent, { date, uuid, state, action, commit, cause, isLast: true }, handler);
 }
 
-function getEventHandler (format, follow) {
+function getEventHandler(format, follow) {
   switch (format) {
     case 'json': {
       if (follow) {
         throw new Error('The `follow` option and "json" format are not compatible. Use "json-stream" format instead.');
-      }
-      else {
+      } else {
         const buf = [];
 
         return {
@@ -132,20 +153,21 @@ function getEventHandler (format, follow) {
   }
 }
 
-export async function activity (params) {
+export async function activity(params) {
   const { alias, app: appIdOrName, 'show-all': showAll, follow, format } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
   const events = await Activity.list(ownerId, appId, showAll);
-  const reversedArrayWithIndex = events
-    .reverse()
-    .map((event, index, all) => {
-      const isLast = index === all.length - 1;
-      return ({ ...event, isLast });
-    });
+  const reversedArrayWithIndex = events.reverse().map((event, index, all) => {
+    const isLast = index === all.length - 1;
+    return { ...event, isLast };
+  });
 
   const handler = getEventHandler(format, follow);
 
-  let lastEvent = reversedArrayWithIndex.reduce((previousEvent, newEvent) => handleEvent(previousEvent, newEvent, handler), {});
+  let lastEvent = reversedArrayWithIndex.reduce(
+    (previousEvent, newEvent) => handleEvent(previousEvent, newEvent, handler),
+    {},
+  );
 
   if (!follow) {
     handler.end();

package/src/commands/addon.js

@@ -1,22 +1,20 @@
-import colors from 'colors/safe.js';
+import { styleText } from 'node:util';
 
+import { getAllEnvVars } from '@clevercloud/client/esm/api/v2/addon.js';
+import { toNameEqualsValueString } from '@clevercloud/client/esm/utils/env-vars.js';
+import dedent from 'dedent';
+import { formatTable } from '../format-table.js';
+import { Logger } from '../logger.js';
 import * as Addon from '../models/addon.js';
+import { findOwnerId, parseAddonOptions } from '../models/addon.js';
 import * as AppConfig from '../models/app_configuration.js';
-import { formatTable as initFormatTable } from '../format-table.js';
-import { Logger } from '../logger.js';
+import { conf } from '../models/configuration.js';
+import { resolveAddonId } from '../models/ids-resolver.js';
 import * as Organisation from '../models/organisation.js';
-import * as User from '../models/user.js';
-import { parseAddonOptions, findOwnerId } from '../models/addon.js';
-import { getAllEnvVars } from '@clevercloud/client/esm/api/v2/addon.js';
 import { sendToApi } from '../models/send-to-api.js';
-import { toNameEqualsValueString } from '@clevercloud/client/esm/utils/env-vars.js';
-import { resolveAddonId } from '../models/ids-resolver.js';
-import { conf } from '../models/configuration.js';
-import dedent from 'dedent';
-
-const formatTable = initFormatTable();
+import * as User from '../models/user.js';
 
-export async function list (params) {
+export async function list(params) {
   const { org: orgaIdOrName, format } = params.options;
 
   const ownerId = await Organisation.getId(orgaIdOrName);
@@ -46,7 +44,7 @@ export async function list (params) {
         return [
           addon.plan.name + ' ' + addon.provider.name,
           addon.region,
-          colors.bold.green(addon.name),
+          styleText(['bold', 'green'], addon.name),
           addon.id,
         ];
       });
@@ -55,7 +53,7 @@ export async function list (params) {
   }
 }
 
-export async function create (params) {
+export async function create(params) {
   const [providerName, name] = params.args;
   const {
     link: linkedAppAlias,
@@ -68,9 +66,7 @@ export async function create (params) {
   const version = params.options['addon-version'];
   const addonOptions = parseAddonOptions(params.options.option);
 
-  const ownerId = (orgaIdOrName != null)
-    ? await Organisation.getId(orgaIdOrName)
-    : await User.getCurrentId();
+  const ownerId = orgaIdOrName != null ? await Organisation.getId(orgaIdOrName) : await User.getCurrentId();
 
   const addonToCreate = {
     ownerId,
@@ -86,23 +82,28 @@ export async function create (params) {
   if (linkedAppAlias != null) {
     const linkedAppData = await AppConfig.getAppDetails({ alias: linkedAppAlias });
     if (orgaIdOrName != null && linkedAppData.ownerId !== ownerId && format === 'human') {
-      Logger.warn('The specified application does not belong to the specified organisation. Ignoring the `--org` option');
+      Logger.warn(
+        'The specified application does not belong to the specified organisation. Ignoring the `--org` option',
+      );
     }
     const newAddon = await Addon.create({
       ...addonToCreate,
       ownerId: linkedAppData.ownerId,
     });
     await Addon.link(linkedAppData.ownerId, linkedAppData.appId, { addon_id: newAddon.id });
-    displayAddon(format, newAddon, providerName, `Add-on created and linked to application ${linkedAppAlias} successfully!`);
-  }
-  else {
+    displayAddon(
+      format,
+      newAddon,
+      providerName,
+      `Add-on created and linked to application ${linkedAppAlias} successfully!`,
+    );
+  } else {
     const newAddon = await Addon.create(addonToCreate);
     displayAddon(format, newAddon, providerName, 'Add-on created successfully!');
   }
 }
 
-function displayAddon (format, addon, providerName, message) {
-
+function displayAddon(format, addon, providerName, message) {
   const PROVIDERS_WITH_URL = {
     keycloak: {
       name: 'Keycloak',
@@ -132,9 +133,9 @@ function displayAddon (format, addon, providerName, message) {
     kv: {
       status: 'alpha',
       postCreateInstructions: dedent`
-        ${colors.yellow('You can easily use Materia KV with \'redis-cli\', with such commands:')}
-        ${colors.blue(`source <(clever addon env ${addon.id} -F shell)`)}
-        ${colors.blue('redis-cli -h $KV_HOST -p $KV_PORT --tls')}
+        ${styleText('yellow', "You can easily use Materia KV with 'redis-cli', with such commands:")}
+        ${styleText('blue', `source <(clever addon env ${addon.id} -F shell)`)}
+        ${styleText('blue', 'redis-cli -h $KV_HOST -p $KV_PORT --tls')}
         Learn more about Materia KV on Clever Cloud: ${conf.DOC_URL}/addons/materia-kv/
       `,
     },
@@ -167,19 +168,14 @@ function displayAddon (format, addon, providerName, message) {
   let providerNameToShow = '';
   let statusMessage = '';
   if (providerName in WIP_PROVIDERS && WIP_PROVIDERS[providerName].status !== '') {
-
-    providerNameToShow = providerName === 'kv'
-      ? 'Materia KV'
-      : providerName;
+    providerNameToShow = providerName === 'kv' ? 'Materia KV' : providerName;
 
     statusMessage = `The ${providerNameToShow} provider is in ${WIP_PROVIDERS[providerName].status} testing phase`;
-    statusMessage += WIP_PROVIDERS[providerName].status === 'alpha'
-      ? '. Don\'t store sensitive or production grade data.'
-      : '';
+    statusMessage +=
+      WIP_PROVIDERS[providerName].status === 'alpha' ? ". Don't store sensitive or production grade data." : '';
   }
 
   switch (format) {
-
     case 'json': {
       const jsonAddon = {
         id: addon.id,
@@ -188,20 +184,17 @@ function displayAddon (format, addon, providerName, message) {
         env: addon.env,
       };
 
-      Logger.printJson((WIP_PROVIDERS[providerName] != null)
-        ? { ...jsonAddon, availability: WIP_PROVIDERS[providerName].status, message: statusMessage }
-        : jsonAddon);
+      Logger.printJson(
+        WIP_PROVIDERS[providerName] != null
+          ? { ...jsonAddon, availability: WIP_PROVIDERS[providerName].status, message: statusMessage }
+          : jsonAddon,
+      );
       break;
     }
 
     case 'human':
     default:
-      Logger.println([
-        message,
-        `ID: ${addon.id}`,
-        `Real ID: ${addon.realId}`,
-        `Name: ${addon.name}`,
-      ].join('\n'));
+      Logger.println([message, `ID: ${addon.id}`, `Real ID: ${addon.realId}`, `Name: ${addon.name}`].join('\n'));
 
       if (providerName in PROVIDERS_WITH_URL) {
         const provider = PROVIDERS_WITH_URL[providerName];
@@ -218,25 +211,34 @@ function displayAddon (format, addon, providerName, message) {
 
         if (providerName === 'keycloak') {
           Logger.println();
-          Logger.println("An initial account has been created, you'll be invited to change the password at first login:");
+          Logger.println(
+            "An initial account has been created, you'll be invited to change the password at first login:",
+          );
           Logger.println(` - Admin user name: ${addon.env.find((e) => e.name === 'CC_KEYCLOAK_ADMIN').value}`);
-          Logger.println(` - Temporary password: ${addon.env.find((e) => e.name === 'CC_KEYCLOAK_ADMIN_DEFAULT_PASSWORD').value}`);
+          Logger.println(
+            ` - Temporary password: ${addon.env.find((e) => e.name === 'CC_KEYCLOAK_ADMIN_DEFAULT_PASSWORD').value}`,
+          );
         }
 
         if (providerName === 'otoroshi') {
           Logger.println();
-          Logger.println('An initial account has been created, change the password at first login (Security -> Administrators -> Edit user):');
-          Logger.println(` - Admin user name: ${addon.env.find((e) => e.name === 'CC_OTOROSHI_INITIAL_ADMIN_LOGIN').value}`);
-          Logger.println(` - Initial password: ${addon.env.find((e) => e.name === 'CC_OTOROSHI_INITIAL_ADMIN_PASSWORD').value}`);
+          Logger.println(
+            'An initial account has been created, change the password at first login (Security -> Administrators -> Edit user):',
+          );
+          Logger.println(
+            ` - Admin user name: ${addon.env.find((e) => e.name === 'CC_OTOROSHI_INITIAL_ADMIN_LOGIN').value}`,
+          );
+          Logger.println(
+            ` - Initial password: ${addon.env.find((e) => e.name === 'CC_OTOROSHI_INITIAL_ADMIN_PASSWORD').value}`,
+          );
         }
       }
 
       if (providerName in WIP_PROVIDERS) {
-
         Logger.println();
 
         if (statusMessage !== '') {
-          Logger.println(colors.yellow(`/!\\ ${statusMessage}`));
+          Logger.println(styleText('yellow', `/!\\ ${statusMessage}`));
         }
 
         Logger.println(WIP_PROVIDERS[providerName].postCreateInstructions);
@@ -244,7 +246,7 @@ function displayAddon (format, addon, providerName, message) {
   }
 }
 
-export async function deleteAddon (params) {
+export async function deleteAddon(params) {
   const { yes: skipConfirmation, org: orgaIdOrName } = params.options;
   const [addon] = params.args;
 
@@ -262,7 +264,7 @@ export async function deleteAddon (params) {
   Logger.println(`Addon ${addon.addon_id || addon.addon_name} successfully deleted`);
 }
 
-export async function rename (params) {
+export async function rename(params) {
   const [addon, newName] = params.args;
   const { org: orgaIdOrName } = params.options;
 
@@ -272,7 +274,7 @@ export async function rename (params) {
   Logger.println(`Addon ${addon.addon_id || addon.addon_name} successfully renamed to ${newName}`);
 }
 
-export async function listProviders (params) {
+export async function listProviders(params) {
   const { format } = params.options;
 
   const providers = await Addon.listProviders();
@@ -296,18 +298,14 @@ export async function listProviders (params) {
     case 'human':
     default: {
       const formattedProviders = providers.map((provider) => {
-        return [
-          colors.bold(provider.id),
-          provider.name,
-          provider.shortDesc || '',
-        ];
+        return [styleText('bold', provider.id), provider.name, provider.shortDesc || ''];
       });
       Logger.println(formatTable(formattedProviders));
     }
   }
 }
 
-export async function showProvider (params) {
+export async function showProvider(params) {
   const [providerName] = params.args;
   const { format } = params.options;
 
@@ -366,7 +364,7 @@ export async function showProvider (params) {
     }
     case 'human':
     default: {
-      Logger.println(colors.bold(formattedProvider.id));
+      Logger.println(styleText('bold', formattedProvider.id));
       Logger.println(`${formattedProvider.name}: ${formattedProvider.shortDesc}`);
       Logger.println();
       Logger.println(`Available regions: ${formattedProvider.regions.join(', ')}`);
@@ -374,11 +372,13 @@ export async function showProvider (params) {
       Logger.println('Available plans');
 
       formattedProvider.plans.forEach((plan) => {
-        Logger.println(`Plan ${colors.bold(plan.slug)}`);
+        Logger.println(`Plan ${styleText('bold', plan.slug)}`);
         plan.features.forEach(({ name, value }) => Logger.println(`  ${name}: ${value}`));
 
         if (plan.versions != null) {
-          Logger.println(`  Available versions: ${plan.versions.map(({ version, isDefault }) => isDefault ? `${version} (default)` : version).join(', ')}`);
+          Logger.println(
+            `  Available versions: ${plan.versions.map(({ version, isDefault }) => (isDefault ? `${version} (default)` : version)).join(', ')}`,
+          );
           plan.versions.forEach(({ version, options }) => {
             Logger.println(`  Options for version ${version}:`);
             options.forEach(({ name, enabledByDefault }) => {
@@ -391,8 +391,7 @@ export async function showProvider (params) {
   }
 }
 
-export async function env (params) {
-
+export async function env(params) {
   const { org, format } = params.options;
   const [addonIdOrRealId] = params.args;
 
@@ -402,11 +401,8 @@ export async function env (params) {
   const envFromAddon = await getAllEnvVars({ id: ownerId, addonId }).then(sendToApi);
 
   switch (format) {
-
     case 'json': {
-      const envFromAddonJson = Object.fromEntries(
-        envFromAddon.map(({ name, value }) => [name, value]),
-      );
+      const envFromAddonJson = Object.fromEntries(envFromAddon.map(({ name, value }) => [name, value]));
       Logger.println(JSON.stringify(envFromAddonJson, null, 2));
       break;
     }

package/src/commands/applications.js

@@ -1,40 +1,37 @@
-import colors from 'colors/safe.js';
+import { styleText } from 'node:util';
 
+import { formatTable } from '../format-table.js';
+import { Logger } from '../logger.js';
 import * as AppConfig from '../models/app_configuration.js';
 import * as Application from '../models/application.js';
 import * as Organisation from '../models/organisation.js';
-import { Logger } from '../logger.js';
-import { formatTable } from '../format-table.js';
 import { truncateWithEllipsis } from '../models/utils.js';
 
-export async function list (params) {
+export async function list(params) {
   const { 'only-aliases': onlyAliases, json } = params.options;
 
   const { apps } = await AppConfig.loadApplicationConf();
 
   const formattedApps = formatApps(apps, onlyAliases, json);
   Logger.println(formattedApps);
-};
-
-function formatApps (apps, onlyAliases, json) {
+}
 
+function formatApps(apps, onlyAliases, json) {
   if (json) {
     if (onlyAliases) {
       apps = apps.map((a) => a.alias);
     }
     return JSON.stringify(apps, null, 2);
-  }
-  else {
+  } else {
     if (onlyAliases) {
       return apps.map((a) => a.alias).join('\n');
-    }
-    else {
+    } else {
       return apps
         .map((app) => {
           const sshUrl = app.git_ssh_url ?? app.deploy_url.replace('https://', 'git+ssh://git@');
           return [
             `Application ${app.name}`,
-            `  alias: ${colors.bold(app.alias)}`,
+            `  alias: ${styleText('bold', app.alias)}`,
             `  ID: ${app.app_id}`,
             `  deployment URL: ${app.deploy_url}`,
             `  git+ssh URL: ${sshUrl}`,
@@ -45,14 +42,12 @@ function formatApps (apps, onlyAliases, json) {
   }
 }
 
-export async function listAll (params) {
+export async function listAll(params) {
   const { org: orgaIdOrName, format } = params.options;
 
   const linkedApps = await AppConfig.loadApplicationConf().then((conf) => conf.apps);
 
-  const ownerId = (orgaIdOrName != null && orgaIdOrName.orga_name !== '')
-    ? await Organisation.getId(orgaIdOrName)
-    : null;
+  const ownerId = orgaIdOrName != null && orgaIdOrName.orga_name !== '' ? await Organisation.getId(orgaIdOrName) : null;
 
   const allAppsPerOrg = await Application.getAllApps(ownerId);
 
@@ -72,7 +67,6 @@ export async function listAll (params) {
     }
     case 'human':
     default: {
-
       const headers = ['APPLICATION ID', 'NAME', 'TYPE', 'ZONE', 'LOCAL ALIAS'];
       const appNameWidth = 42;
 
@@ -85,29 +79,37 @@ export async function listAll (params) {
         getPropertyMaxWidth(allApps, 'zone'),
         getPropertyMaxWidth(allApps, 'alias'),
       ];
-      const formatTableWithColumnWidth = formatTable(columnWidths);
 
       allAppsWithAliasPerOrg.forEach((org) => {
-
         Logger.println();
 
         const applicationsPlural = org.applications.length !== 1 ? 'applications' : 'application';
         const punctuation = org.applications.length > 0 ? ':' : '';
 
-        Logger.println(colors.blue(`• Organization '${org.name}' (${org.id}) with ${org.applications.length} ${applicationsPlural}${punctuation}`));
+        Logger.println(
+          styleText(
+            'blue',
+            `• Organization '${org.name}' (${org.id}) with ${org.applications.length} ${applicationsPlural}${punctuation}`,
+          ),
+        );
 
         if (org.applications.length > 0) {
           Logger.println();
-          Logger.println(formatTableWithColumnWidth([
-            headers,
-            ...org.applications.map((app) => [
-              app.app_id,
-              truncateWithEllipsis(appNameWidth, app.name),
-              app.type,
-              app.zone,
-              app.alias,
-            ]),
-          ]));
+          Logger.println(
+            formatTable(
+              [
+                headers,
+                ...org.applications.map((app) => [
+                  app.app_id,
+                  truncateWithEllipsis(appNameWidth, app.name),
+                  app.type,
+                  app.zone,
+                  app.alias,
+                ]),
+              ],
+              columnWidths,
+            ),
+          );
         }
       });
 
@@ -116,6 +118,6 @@ export async function listAll (params) {
   }
 }
 
-function getPropertyMaxWidth (array, propertyName) {
+function getPropertyMaxWidth(array, propertyName) {
   return Math.max(...array.map((o) => o[propertyName].length));
 }

package/src/commands/cancel-deploy.js

@@ -1,19 +1,19 @@
-import * as Application from '../models/application.js';
+import { cancelDeployment, getAllDeployments } from '@clevercloud/client/esm/api/v2/application.js';
+import { styleText } from 'node:util';
 import { Logger } from '../logger.js';
-import { getAllDeployments, cancelDeployment } from '@clevercloud/client/esm/api/v2/application.js';
+import * as Application from '../models/application.js';
 import { sendToApi } from '../models/send-to-api.js';
-import colors from 'colors/safe.js';
 
-export async function cancelDeploy (params) {
+export async function cancelDeploy(params) {
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   const deployments = await getAllDeployments({ id: ownerId, appId, limit: 1 }).then(sendToApi);
 
-  if (deployments.length === 0 || (deployments[0].action !== 'DEPLOY' || deployments[0].state !== 'WIP')) {
+  if (deployments.length === 0 || deployments[0].action !== 'DEPLOY' || deployments[0].state !== 'WIP') {
     throw new Error('There is no ongoing deployment for this application');
   }
 
   await cancelDeployment({ id: ownerId, appId, deploymentId: deployments[0].id }).then(sendToApi);
-  Logger.printSuccess(`Deployment ${colors.bold.green(deployments[0].uuid)} successfully cancelled!`);
-};
+  Logger.printSuccess(`Deployment ${styleText(['bold', 'green'], deployments[0].uuid)} successfully cancelled!`);
+}