clever-tools 4.5.2 → 4.6.0

package/src/lib/profile.js

@@ -0,0 +1,116 @@
+import { get as getUser } from '@clevercloud/client/esm/api/v2/organisation.js';
+import { getCurrentTokenInfo } from '@clevercloud/client/esm/api/v2/self.js';
+import { baseConfig } from '../config/config.js';
+import { sendToApiWithConfig } from '../models/send-to-api.js';
+import { formatDateLocalized, toDate } from './date-utils.js';
+import { styleText } from './style-text.js';
+
+/**
+ * @typedef {import('../config/config.js').Profile} Profile
+ */
+
+/**
+ * @typedef {object} ProfileDetails
+ * @property {string} alias
+ * @property {string} email
+ * @property {string | null | undefined} name
+ * @property {string} [id]
+ * @property {Date} [tokenExpiration]
+ * @property {boolean} has2FA
+ * @property {string} [avatar]
+ * @property {Date} [creationDate]
+ * @property {string} [lang]
+ * @property {boolean} isProfileActive
+ * @property {boolean} isTokenValid
+ * @property {Record<string, string>} [overrides]
+ */
+
+/**
+ * Formats a profile for display.
+ * @param {Profile | ProfileDetails} profile
+ * @returns {string}
+ */
+export function formatProfile(profile) {
+  return [
+    profile.alias,
+    profile.email != null ? `(${profile.email})` : null,
+    profile.isProfileActive ? styleText('green', '[active]') : null,
+  ]
+    .filter(Boolean)
+    .join(' ');
+}
+
+/**
+ * Fetch full profile details using the profile's credentials.
+ * @param {object} params
+ * @param {Profile} params.profile
+ * @param {boolean} params.isActive
+ * @returns {Promise<ProfileDetails>}
+ */
+export async function getProfileDetails({ profile, isActive }) {
+  const sendWithCredentials = sendToApiWithConfig({
+    token: profile.token,
+    secret: profile.secret,
+    apiHost: profile.overrides?.API_HOST ?? baseConfig.API_HOST,
+    consumerKey: profile.overrides?.OAUTH_CONSUMER_KEY ?? baseConfig.OAUTH_CONSUMER_KEY,
+    consumerSecret: profile.overrides?.OAUTH_CONSUMER_SECRET ?? baseConfig.OAUTH_CONSUMER_SECRET,
+  });
+
+  const [user, token] = await Promise.all([
+    getUser({}).then(sendWithCredentials),
+    getCurrentTokenInfo().then(sendWithCredentials),
+  ]).catch(() => [null, null]);
+
+  return {
+    id: user?.id ?? profile.userId,
+    email: user?.email ?? profile.email,
+    name: user?.name,
+    avatar: user?.avatar,
+    creationDate: toDate(user?.creationDate),
+    tokenExpiration: toDate(token?.expirationDate ?? profile.expirationDate),
+    lang: user?.lang,
+    has2FA: user != null ? user.preferredMFA != null && user.preferredMFA !== 'NONE' : undefined,
+    alias: profile.alias,
+    isProfileActive: isActive,
+    isTokenValid: user != null,
+    overrides: profile.overrides,
+  };
+}
+
+/**
+ * Formats profile details for CLI display.
+ * @param {ProfileDetails} profile
+ */
+export function formatProfileDetails(profile) {
+  const lines = [];
+
+  lines.push(styleText('bold', formatProfile(profile)));
+  lines.push(profile.id);
+
+  if (!profile.isTokenValid) {
+    lines.push(styleText('red', 'Invalid or expired token'));
+    return lines.map((line, index) => (index === 0 ? line : `  ${line}`)).join('\n');
+  }
+
+  lines.push(profile.name ? profile.name : '[unknown]');
+
+  const expiresAtFormatted = formatDateLocalized(profile.tokenExpiration);
+  if (expiresAtFormatted) {
+    lines.push(`Expires on ${styleText('gray', expiresAtFormatted)}`);
+  }
+
+  lines.push(`2FA ${profile.has2FA ? styleText('green', 'enabled ✓') : styleText('red', 'disabled ✗')}`);
+
+  if (profile.overrides != null) {
+    const overrideEntries = Object.entries(profile.overrides).filter(([, v]) => v != null);
+    for (const [key, value] of overrideEntries) {
+      lines.push(`${key}: ${styleText('gray', value)}`);
+    }
+  }
+
+  return lines
+    .map((line, index) => {
+      return index === 0 ? line : `  ${line}`;
+    })
+    .join('\n');
+}

package/src/logger.js

@@ -1,85 +1,139 @@
-import _ from 'lodash';
 import { format } from 'node:util';
 import { styleText } from './lib/style-text.js';
 
-function getPrefix(severity) {
-  const prefix = `[${severity.toUpperCase()}] `;
-  const prefixLength = prefix.length;
-  if (severity === 'error') {
-    return { prefix: styleText(['bold', 'red'], prefix), prefixLength };
-  }
-  return { prefix, prefixLength };
-}
+/**
+ * @typedef {import('./logger.types.js').ApiError} ApiError
+ */
 
-function processApiError(error) {
-  if (error.id == null || error.message == null) {
-    return error;
-  }
-  const fields = _.map(error.fields, (msg, field) => `${field}: ${msg}`);
-  return [`${error.message} [${error.id}]`, ...fields].join('\n');
-}
+const IS_QUIET = Boolean(process.env.CLEVER_QUIET);
+const IS_VERBOSE = Boolean(process.env.CLEVER_VERBOSE);
 
-function formatLines(prefixLength, lines) {
-  const blankPrefix = _.repeat(' ', prefixLength);
-  return (lines || '')
-    .split('\n')
-    .map((line, i) => (i === 0 ? line : `${blankPrefix}${line}`))
-    .join('\n');
-}
+export const Logger = {
+  /**
+   * @param {string} message
+   */
+  debug(message) {
+    consoleLog('debug', message);
+  },
 
-function consoleErrorWithoutColor(line) {
-  process.stderr.write(format(line) + '\n');
-}
+  /**
+   * @param {string} message
+   */
+  info(message) {
+    consoleLog('info', message);
+  },
+
+  /**
+   * @param {string} message
+   */
+  warn(message) {
+    consoleLog('warn', message);
+  },
+
+  /**
+   * @param {Error|string} error
+   */
+  error(error) {
+    if (IS_QUIET) {
+      return;
+    }
+
+    const prefix = '[ERROR] ';
+    const styledPrefix = styleText(['bold', 'red'], prefix);
+    const message = error instanceof Error ? error.message : error;
+    const formatted = formatLines(prefix.length, processApiError(message));
 
-export const Logger = _(['debug', 'info', 'warn', 'error'])
-  .map((severity) => {
-    if (process.env.CLEVER_QUIET || (!process.env.CLEVER_VERBOSE && (severity === 'debug' || severity === 'info'))) {
-      return [severity, _.noop];
+    if (IS_VERBOSE) {
+      writeStderr('[STACKTRACE]');
+      writeStderr(error);
+      writeStderr('[/STACKTRACE]');
     }
-    const consoleFn = severity === 'error' ? consoleErrorWithoutColor : console.log;
-    const { prefix, prefixLength } = getPrefix(severity);
-    return [
-      severity,
-      (err) => {
-        const message = _.get(err, 'message', err);
-        const formattedMsg = formatLines(prefixLength, processApiError(message));
-        if (process.env.CLEVER_VERBOSE && severity === 'error') {
-          consoleErrorWithoutColor('[STACKTRACE]');
-          consoleErrorWithoutColor(err);
-          consoleErrorWithoutColor('[/STACKTRACE]');
-        }
-        return consoleFn(`${prefix}${formattedMsg}`);
-      },
-    ];
-  })
-  .fromPairs()
-  .value();
-
-// No decoration for Logger.println
-Logger.println = console.log;
+    writeStderr(`${styledPrefix}${formatted}`);
+  },
+
+  println: console.log,
+
+  /**
+   * @param {string} text
+   * @param {number} indentLevel
+   */
+  printlnWithIndent(text, indentLevel) {
+    console.log(' '.repeat(indentLevel) + text);
+  },
+
+  /** @param {string} message */
+  printSuccess(message) {
+    console.log(`${styleText(['bold', 'green'], '✓')} ${message}`);
+  },
+
+  /** @param {string} message */
+  printInfo(message) {
+    console.log(`${styleText('blue', 'i')} ${message}`);
+  },
+
+  /** @param {unknown} obj */
+  printJson(obj) {
+    console.log(JSON.stringify(obj, null, 2));
+  },
+
+  printErrorLine: writeStderr,
+};
 
 /**
- * Prints a line of text with specified indentation.
- *
- * @param {string} text - The text to be printed.
- * @param {number} indentLevel - The number of spaces to indent the text.
+ * Logs a message to the console with severity prefix.
+ * @param {'debug'|'info'|'warn'} severity
+ * @param {string} message
+ * @returns {void}
  */
-Logger.printlnWithIndent = (text, indentLevel) => {
-  Logger.println(' '.repeat(indentLevel) + text);
-};
+function consoleLog(severity, message) {
+  if (IS_QUIET) {
+    return;
+  }
+  if (!IS_VERBOSE && severity !== 'warn') {
+    return;
+  }
+  const prefix = `[${severity.toUpperCase()}] `;
+  console.log(`${prefix}${formatLines(prefix.length, message)}`);
+}
 
-// Logger for success with a green check before the message
-Logger.printSuccess = (message) => console.log(`${styleText(['bold', 'green'], '✓')} ${message}`);
+/**
+ * Writes a formatted line to stderr.
+ * @param {Error|string} value
+ * @returns {void}
+ */
+function writeStderr(value) {
+  process.stderr.write(format(value) + '\n');
+}
 
-// Logger for information with a blue 'i' before the message
-Logger.printInfo = (message) => console.log(`${styleText('blue', 'i')} ${message}`);
+/**
+ * Formats a multiline message with indentation for continuation lines.
+ * @param {number} prefixLength
+ * @param {string} message
+ * @returns {string}
+ */
+function formatLines(prefixLength, message) {
+  const indent = ' '.repeat(prefixLength);
+  return message
+    .split('\n')
+    .map((line, i) => (i === 0 ? line : indent + line))
+    .join('\n');
+}
 
-// No decoration for Logger.println
-Logger.printJson = (obj) => {
-  console.log(JSON.stringify(obj, null, 2));
-};
+/**
+ * Transforms an API error object into a formatted message string.
+ * @param {ApiError|string} error
+ * @returns {string}
+ */
+function processApiError(error) {
+  if (typeof error === 'string') {
+    return error;
+  }
 
-Logger.printErrorLine = consoleErrorWithoutColor;
+  const { id, message, fields } = error;
+  if (id == null || message == null) {
+    return String(error);
+  }
 
-// Only exported for testing, shouldn't be used directly
-Logger.processApiError = processApiError;
+  const fieldLines = Object.entries(fields ?? {}).map(([name, msg]) => `${name}: ${msg}`);
+  return [`${message} [${id}]`, ...fieldLines].join('\n');
+}

package/src/logger.types.d.ts

@@ -0,0 +1,5 @@
+export interface ApiError {
+  id?: string;
+  message?: string;
+  fields?: Record<string, string>;
+}

package/src/models/app_configuration.js

@@ -1,25 +1,24 @@
 import _ from 'lodash';
-import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import { config } from '../config/config.js';
+import { readJson, writeJson } from '../lib/fs.js';
 import { slugify } from '../lib/slugify.js';
 import { styleText } from '../lib/style-text.js';
 import { Logger } from '../logger.js';
-import { conf } from './configuration.js';
 import * as User from './user.js';
 
 // TODO: Maybe use fs-utils findPath()
 export async function loadApplicationConf(ignoreParentConfig = false, pathToFolder) {
   if (pathToFolder == null) {
-    pathToFolder = path.dirname(conf.APP_CONFIGURATION_FILE);
+    pathToFolder = path.dirname(config.APP_CONFIGURATION_FILE);
   }
-  const fileName = path.basename(conf.APP_CONFIGURATION_FILE);
+  const fileName = path.basename(config.APP_CONFIGURATION_FILE);
   const fullPath = path.join(pathToFolder, fileName);
   Logger.debug('Loading app configuration from ' + fullPath);
   try {
-    const contents = await fs.readFile(fullPath);
-    return JSON.parse(contents);
+    return await readJson(fullPath);
   } catch (error) {
-    Logger.info('Cannot load app configuration from ' + conf.APP_CONFIGURATION_FILE + ' (' + error + ')');
+    Logger.info('Cannot load app configuration from ' + config.APP_CONFIGURATION_FILE + ' (' + error + ')');
     if (ignoreParentConfig || path.parse(pathToFolder).root === pathToFolder) {
       return { apps: [] };
     }
@@ -30,25 +29,34 @@ export async function loadApplicationConf(ignoreParentConfig = false, pathToFold
 export async function addLinkedApplication(appData, alias, ignoreParentConfig) {
   const currentConfig = await loadApplicationConf(ignoreParentConfig);
 
+  const generatedAlias = alias || slugify(appData.name);
+
+  const existingApp = currentConfig.apps.find((app) => app.app_id === appData.id);
+  if (existingApp != null) {
+    throw new Error(
+      `Application ${styleText('red', appData.id)} is already linked with alias ${styleText('red', existingApp.alias)}`,
+    );
+  }
+
+  const aliasConflict = currentConfig.apps.find((app) => app.alias === generatedAlias);
+  if (aliasConflict != null) {
+    throw new Error(
+      `An application with alias ${styleText('red', generatedAlias)} is already linked. Please specify a different alias with ${styleText('blue', '--alias')}.`,
+    );
+  }
+
   const appEntry = {
     app_id: appData.id,
     org_id: appData.ownerId,
     deploy_url: appData.deployment.httpUrl || appData.deployment.url,
     git_ssh_url: appData.deployment.url,
     name: appData.name,
-    alias: alias || slugify(appData.name),
+    alias: generatedAlias,
   };
 
-  const isPresent = currentConfig.apps.find((app) => app.app_id === appEntry.app_id) != null;
-  if (isPresent) {
-    throw new Error(
-      `Application ${styleText('red', appEntry.app_id)} is already linked with alias ${styleText('red', appEntry.alias)}`,
-    );
-  }
-
   currentConfig.apps.push(appEntry);
 
-  return persistConfig(currentConfig).then(() => {
+  return writeJson(config.APP_CONFIGURATION_FILE, currentConfig).then(() => {
     return appEntry;
   });
 }
@@ -69,17 +77,17 @@ export async function removeLinkedApplication({ appId, alias }) {
     delete newConfig.default;
   }
 
-  await persistConfig(newConfig);
+  await writeJson(config.APP_CONFIGURATION_FILE, newConfig);
   return true;
 }
 
-export function findApp(config, alias) {
-  if (_.isEmpty(config.apps)) {
+export function findApp(appConfig, alias) {
+  if (_.isEmpty(appConfig.apps)) {
     throw new Error('There is no linked or targeted application. Use `--app` option or `clever link` command.');
   }
 
   if (alias != null) {
-    const [appByAlias, secondAppByAlias] = _.filter(config.apps, { alias });
+    const [appByAlias, secondAppByAlias] = _.filter(appConfig.apps, { alias });
     if (appByAlias == null) {
       throw new Error(`There are no applications matching alias ${alias}`);
     }
@@ -91,7 +99,7 @@ export function findApp(config, alias) {
     return appByAlias;
   }
 
-  return findDefaultApp(config);
+  return findDefaultApp(appConfig);
 }
 
 export function checkAlreadyLinked(apps, name, alias) {
@@ -106,13 +114,13 @@ export function checkAlreadyLinked(apps, name, alias) {
   }
 }
 
-function findDefaultApp(config) {
-  if (_.isEmpty(config.apps)) {
+function findDefaultApp(appConfig) {
+  if (_.isEmpty(appConfig.apps)) {
     throw new Error('There is no linked or targeted application. Use `--app` option or `clever link` command.');
   }
 
-  if (config.default != null) {
-    const defaultApp = _.find(config.apps, { app_id: config.default });
+  if (appConfig.default != null) {
+    const defaultApp = _.find(appConfig.apps, { app_id: appConfig.default });
     if (defaultApp == null) {
       throw new Error(
         'The default application is not listed anymore. This should not happen, your `.clever.json` should be fixed.',
@@ -121,19 +129,19 @@ function findDefaultApp(config) {
     return defaultApp;
   }
 
-  if (config.apps.length === 1) {
-    return config.apps[0];
+  if (appConfig.apps.length === 1) {
+    return appConfig.apps[0];
   }
 
-  const aliases = _.map(config.apps, 'alias').join(', ');
+  const aliases = _.map(appConfig.apps, 'alias').join(', ');
   throw new Error(
     `Several applications are linked. You can specify one with the "--alias" option. Run "clever applications" to list linked applications. Available aliases: ${aliases}`,
   );
 }
 
 export async function getAppDetails({ alias }) {
-  const config = await loadApplicationConf();
-  const app = findApp(config, alias);
+  const appConfig = await loadApplicationConf();
+  const app = findApp(appConfig, alias);
   const ownerId = app.org_id != null ? app.org_id : await User.getCurrentId();
   return {
     appId: app.app_id,
@@ -144,14 +152,9 @@ export async function getAppDetails({ alias }) {
   };
 }
 
-function persistConfig(modifiedConfig) {
-  const jsonContents = JSON.stringify(modifiedConfig, null, 2);
-  return fs.writeFile(conf.APP_CONFIGURATION_FILE, jsonContents);
-}
-
 export async function setDefault(alias) {
-  const config = await loadApplicationConf();
-  const app = findApp(config, alias);
-  const newConfig = { ...config, default: app.app_id };
-  return persistConfig(newConfig);
+  const appConfig = await loadApplicationConf();
+  const app = findApp(appConfig, alias);
+  const newConfig = { ...appConfig, default: app.app_id };
+  return writeJson(config.APP_CONFIGURATION_FILE, newConfig);
 }

package/src/models/application_configuration.js

@@ -12,7 +12,7 @@ const CONFIG_KEYS = [
 ];
 
 export function listAvailableIds(asText = false) {
-  const ids = CONFIG_KEYS.map((config) => config.id);
+  const ids = CONFIG_KEYS.map((configKey) => configKey.id);
   if (asText) {
     return new Intl.ListFormat('en', { style: 'short', type: 'disjunction' }).format(ids);
   }
@@ -20,9 +20,9 @@ export function listAvailableIds(asText = false) {
 }
 
 export function getById(id) {
-  const config = CONFIG_KEYS.find((config) => config.id === id);
-  if (config != null) {
-    return config;
+  const configKey = CONFIG_KEYS.find((ck) => ck.id === id);
+  if (configKey != null) {
+    return configKey;
   }
   throw new Error(dedent`
     Invalid configuration name: ${id}.
@@ -30,8 +30,8 @@ export function getById(id) {
   `);
 }
 
-export function formatValue(config, value) {
-  switch (config.kind) {
+export function formatValue(configKey, value) {
+  switch (configKey.kind) {
     case 'bool': {
       return value;
     }
@@ -50,8 +50,8 @@ export function formatValue(config, value) {
   }
 }
 
-export function parse(config, value) {
-  switch (config.kind) {
+export function parse(configKey, value) {
+  switch (configKey.kind) {
     case 'bool':
     case 'inverted-bool':
     case 'force-https':
@@ -59,16 +59,16 @@ export function parse(config, value) {
       if (value !== 'true' && value !== 'false') {
         throw new Error('Invalid configuration value, it must be a boolean (true or false)');
       }
-      if (config.kind === 'bool') {
+      if (configKey.kind === 'bool') {
         return value === 'true';
       }
-      if (config.kind === 'inverted-bool') {
+      if (configKey.kind === 'inverted-bool') {
         return value === 'false';
       }
-      if (config.kind === 'force-https') {
+      if (configKey.kind === 'force-https') {
         return value === 'true' ? 'ENABLED' : 'DISABLED';
       }
-      if (config.kind === 'task') {
+      if (configKey.kind === 'task') {
         return value === 'false' ? 'REGULAR' : 'TASK';
       }
       return;
@@ -80,54 +80,54 @@ export function parse(config, value) {
 }
 
 export function parseOptions(options) {
-  const newOptions = CONFIG_KEYS.map((config) => {
-    return parseConfigOption(config, options);
+  const newOptions = CONFIG_KEYS.map((configKey) => {
+    return parseConfigOption(configKey, options);
   }).filter((a) => {
     return a != null && a[1] != null;
   });
   return Object.fromEntries(newOptions);
 }
 
-function parseConfigOption(config, options) {
-  switch (config.kind) {
+function parseConfigOption(configKey, options) {
+  switch (configKey.kind) {
     case 'bool':
     case 'inverted-bool':
     case 'force-https':
     case 'task': {
-      const enable = options[`enable-${config.id}`];
-      const disable = options[`disable-${config.id}`];
+      const enable = options[`enable-${configKey.id}`];
+      const disable = options[`disable-${configKey.id}`];
       if (enable && disable) {
-        throw new Error(`You cannot use both --enable-${config.id} and --disable-${config.id} at the same time`);
+        throw new Error(`You cannot use both --enable-${configKey.id} and --disable-${configKey.id} at the same time`);
       }
       if (enable || disable) {
-        if (config.kind === 'bool') {
-          return [config.name, enable];
+        if (configKey.kind === 'bool') {
+          return [configKey.name, enable];
         }
-        if (config.kind === 'inverted-bool') {
-          return [config.name, disable];
+        if (configKey.kind === 'inverted-bool') {
+          return [configKey.name, disable];
         }
-        if (config.kind === 'force-https' || config.kind === 'task') {
-          return [config.name, parse(config, String(enable))];
+        if (configKey.kind === 'force-https' || configKey.kind === 'task') {
+          return [configKey.name, parse(configKey, String(enable))];
         }
       }
       return;
     }
     default: {
-      return [config.name, options[config.id]];
+      return [configKey.name, options[configKey.id]];
     }
   }
 }
 
 export function printValue(app, id) {
-  const config = getById(id);
-  Logger.println(formatValue(config, app[config.name]));
+  const configKey = getById(id);
+  Logger.println(formatValue(configKey, app[configKey.name]));
 }
 
 export function printAllValues(app) {
   console.table(
     Object.fromEntries(
-      CONFIG_KEYS.map((config) => {
-        return [config.id, formatValue(config, app[config.name])];
+      CONFIG_KEYS.map((configKey) => {
+        return [configKey.id, formatValue(configKey, app[configKey.name])];
       }),
     ),
   );

package/src/models/config-provider.js

@@ -0,0 +1,34 @@
+import { get as getAddon } from '@clevercloud/client/esm/api/v2/addon.js';
+import { findAddonsByNameOrId } from './ids-resolver.js';
+import { sendToApi } from './send-to-api.js';
+
+/**
+ * Resolve a config provider ID from a name, ID or real ID
+ * @param {string} addonIdOrRealIdOrName The add-on ID (addon_xxx), real ID (config_xxx) or name
+ * @returns {Promise<{ ownerId: string, realId: string, addonId: string }>} The owner ID, real ID and addon ID
+ * @throws {Error} If the add-on is not found
+ * @throws {Error} If multiple add-ons are found with the same name
+ * @throws {Error} If the add-on is not a configuration provider
+ */
+export async function resolveConfigProviderId(addonIdOrRealIdOrName) {
+  const candidates = await findAddonsByNameOrId(addonIdOrRealIdOrName);
+
+  if (candidates.length === 0) {
+    throw new Error(`Config provider not found: ${addonIdOrRealIdOrName}`);
+  }
+
+  if (candidates.length > 1) {
+    throw new Error(`Ambiguous config provider name '${addonIdOrRealIdOrName}', please use the ID`);
+  }
+
+  const { ownerId, addonId, realId } = candidates[0];
+
+  // Verify that the addon is a config provider
+  const addon = await getAddon({ id: ownerId, addonId }).then(sendToApi);
+
+  if (addon.provider.id !== 'config-provider') {
+    throw new Error(`The add-on '${addonIdOrRealIdOrName}' is not a configuration provider`);
+  }
+
+  return { ownerId, realId, addonId };
+}