clever-tools 4.3.0 → 4.4.0

package/README.md

@@ -7,7 +7,7 @@ The official CLI for [Clever Cloud](https://www.clever.cloud) - Deploy and manag
 
 ## Quick Start
 
-**Prerequisites:** Node.js 22+ 
+**Prerequisites:** Node.js 22+
 
 ```bash
 # Install globally
@@ -38,7 +38,7 @@ For Node.js users, npm is the fastest way. For other installation methods includ
 
 - Docker images
 - Binary downloads
-- Native packages (RPM, DEB)  
+- Native packages (RPM, DEB)
 - Package managers (Homebrew, WinGet, AUR)
 
 See our complete [setup guide](docs/setup-systems.md).
@@ -51,15 +51,15 @@ Enable smart autocompletion for bash or zsh:
 # Bash
 clever --bash-autocomplete-script $(which clever) | sudo tee /usr/share/bash-completion/completions/clever
 
-# Zsh  
+# Zsh
 clever --zsh-autocomplete-script $(which clever) | sudo tee /usr/share/zsh/site-functions/_clever
 ```
 
 ## Documentation
 
-- **[Complete CLI Documentation](https://www.clever-cloud.com/developers/doc/cli/)** - Official user guide
-- **[CLI Reference](https://www.clever-cloud.com/developers/doc/reference/cli/)** - Complete command reference
-- **[Deployment Examples](https://www.clever-cloud.com/developers/guides/)** - Real-world tutorials
+- **[Complete CLI Documentation](https://www.clever.cloud/developers/doc/cli/)** - Official user guide
+- **[CLI Reference](https://www.clever.cloud/developers/doc/reference/cli/)** - Complete command reference
+- **[Deployment Examples](https://www.clever.cloud/developers/guides/)** - Real-world tutorials
 
 ## Basic Usage
 
@@ -100,7 +100,7 @@ clever logs --since 1h
 clever restart --app <app_id>
 ```
 
-Learn more in our [Application Management Guide](https://www.clever-cloud.com/developers/doc/cli/applications/).
+Learn more in our [Application Management Guide](https://www.clever.cloud/developers/doc/cli/applications/).
 
 ### Add-ons & Services Management
 
@@ -121,7 +121,7 @@ clever features enable operatos
 clever keycloak get myKetcloak
 ```
 
-Learn more in our [Add-ons & Services Guide](https://www.clever-cloud.com/developers/doc/cli/addons/).
+Learn more in our [Add-ons & Services Guide](https://www.clever.cloud/developers/doc/cli/addons/).
 
 # Create and manage
 
@@ -144,7 +144,7 @@ clever tokens create myTokenName
 clever tokens create myTokenName --expiration 2w --format json
 ```
 
-Learn more about API integration in our [API How-to Guide](https://www.clever-cloud.com/developers/api/howto).
+Learn more about API integration in our [API How-to Guide](https://www.clever.cloud/developers/api/howto).
 
 ### Get Help
 

package/bin/clever.js

@@ -168,8 +168,8 @@ async function run() {
     }),
     drainId: cliparse.argument('drain-id', { description: 'Drain ID' }),
     drainType: cliparse.argument('drain-type', {
-      description: 'Drain type',
-      complete: Drain.listDrainTypes,
+      description: Drain.DRAIN_TYPE_CLI_CODES.join(', '),
+      complete: Drain.DRAIN_TYPE_CLI_CODES,
     }),
     drainUrl: cliparse.argument('drain-url', { description: 'Drain URL' }),
     fqdn: cliparse.argument('fqdn', { description: 'Domain name of the application' }),
@@ -420,7 +420,7 @@ async function run() {
     drainPassword: cliparse.option('password', {
       aliases: ['p'],
       metavar: 'password',
-      description: '(HTTP drains) basic auth password',
+      description: 'Basic auth password (for elasticsearch or raw-http)',
     }),
     addonPlan: cliparse.option('plan', {
       aliases: ['p'],
@@ -492,22 +492,22 @@ async function run() {
     drainUsername: cliparse.option('username', {
       aliases: ['u'],
       metavar: 'username',
-      description: '(HTTP drains) basic auth username',
+      description: 'Basic auth username (for elasticsearch or raw-http)',
     }),
-    drainAPIKey: cliparse.option('api-key', {
+    drainApiKey: cliparse.option('api-key', {
       aliases: ['k'],
       metavar: 'api_key',
-      description: '(NewRelic drains) API key',
+      description: 'API key (for newrelic)',
     }),
     drainIndexPrefix: cliparse.option('index-prefix', {
       aliases: ['i'],
       metavar: 'index_prefix',
-      description: '(ElasticSearch drains) optional index prefix. `logstash` value is used if not set',
+      description: 'Optional index prefix (for elasticsearch), `logstash` value is used if not set',
     }),
-    drainSDParameters: cliparse.option('sd-params', {
+    drainSdParameters: cliparse.option('sd-params', {
       aliases: ['s'],
       metavar: 'sd_params',
-      description: '(TCP and UDP drains) sd-params string (e.g.: `X-OVH-TOKEN=\\"REDACTED\\"`)',
+      description: 'RFC5424 structured data parameters (for ovh-tcp), e.g.: `X-OVH-TOKEN=\\"REDACTED\\"`',
     }),
     verbose: cliparse.flag('verbose', { aliases: ['v'], description: 'Verbose output' }),
     color: cliparse.flag('color', {
@@ -870,20 +870,29 @@ async function run() {
       options: [
         opts.drainUsername,
         opts.drainPassword,
-        opts.drainAPIKey,
+        opts.drainApiKey,
         opts.drainIndexPrefix,
-        opts.drainSDParameters,
+        opts.drainSdParameters,
       ],
     },
     drain.create,
   );
+  const drainGetCommand = cliparse.command(
+    'get',
+    {
+      description: 'Get drain info',
+      args: [args.drainId],
+      privateOptions: [opts.humanJsonOutputFormat],
+    },
+    drain.get,
+  );
   const drainRemoveCommand = cliparse.command(
     'remove',
     {
       description: 'Remove a drain',
       args: [args.drainId],
     },
-    drain.rm,
+    drain.remove,
   );
   const drainEnableCommand = cliparse.command(
     'enable',
@@ -905,9 +914,9 @@ async function run() {
     'drain',
     {
       description: 'Manage drains',
-      options: [opts.alias, opts.appIdOrName, opts.addonId],
+      options: [opts.alias, opts.appIdOrName],
       privateOptions: [opts.humanJsonOutputFormat],
-      commands: [drainCreateCommand, drainRemoveCommand, drainEnableCommand, drainDisableCommand],
+      commands: [drainCreateCommand, drainGetCommand, drainRemoveCommand, drainEnableCommand, drainDisableCommand],
     },
     drain.list,
   );
@@ -1611,6 +1620,14 @@ async function run() {
     },
     otoroshi.get,
   );
+  const otoroshiGetConfigCommand = cliparse.command(
+    'get-config',
+    {
+      description: 'Get configuration of a deployed Otoroshi in otoroshictl format',
+      args: [args.addonIdOrName],
+    },
+    otoroshi.getConfig,
+  );
   const otoroshiEnableNgCommand = cliparse.command(
     'enable-ng',
     {
@@ -1703,6 +1720,7 @@ async function run() {
       privateOptions: [opts.humanJsonOutputFormat],
       commands: [
         otoroshiGetCommand,
+        otoroshiGetConfigCommand,
         otoroshiEnableNgCommand,
         otoroshiDisableNgCommand,
         otoroshiOpenCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clever-tools",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "Command Line Interface for Clever Cloud.",
   "keywords": [
     "cli",
@@ -90,6 +90,7 @@
     "node": ">=22"
   },
   "volta": {
-    "node": "22.17.0"
+    "node": "22.17.0",
+    "npm": "11.6.2"
   }
 }

package/src/clever-client/drains.js

@@ -0,0 +1,127 @@
+// TODO: Move this to the Clever Cloud JS Client
+
+/**
+ * GET /v4/drains/organisations/{ownerId}/applications/{applicationId}/drains?status={status}&executionStatus={executionStatus}&executionStatusNotIn={executionStatusNotIn}
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.applicationId
+ * @param {String} params.status
+ * @param {String} params.executionStatus
+ * @param {String} params.executionStatusNotIn
+ */
+export function getDrains(params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/drains/organisations/${params.ownerId}/applications/${params.applicationId}/drains`,
+    headers: { Accept: 'application/json' },
+    queryParams: {
+      status: params.status,
+      executionStatus: params.executionStatus,
+      executionStatusNotIn: params.executionStatusNotIn,
+    },
+    // no body
+  });
+}
+
+/**
+ * POST /v4/drains/organisations/{ownerId}/applications/{applicationId}/drains
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.applicationId
+ * @param {Object} params.body
+ */
+export function createDrain(params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'post',
+    url: `/v4/drains/organisations/${params.ownerId}/applications/${params.applicationId}/drains`,
+    headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
+    body: params.body,
+  });
+}
+
+/**
+ * DELETE /v4/drains/organisations/{ownerId}/applications/{applicationId}/drains/{drainId}
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.applicationId
+ * @param {String} params.drainId
+ */
+export function deleteDrain(params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'delete',
+    url: `/v4/drains/organisations/${params.ownerId}/applications/${params.applicationId}/drains/${params.drainId}`,
+    headers: { Accept: 'application/json' },
+    // no body
+  });
+}
+
+/**
+ * GET /v4/drains/organisations/{ownerId}/applications/{applicationId}/drains/{drainId}
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.applicationId
+ * @param {String} params.drainId
+ */
+export function getDrain(params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/drains/organisations/${params.ownerId}/applications/${params.applicationId}/drains/${params.drainId}`,
+    headers: { Accept: 'application/json' },
+    // no body
+  });
+}
+
+/**
+ * PUT /v4/drains/organisations/{ownerId}/applications/{applicationId}/drains/{drainId}/disable
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.applicationId
+ * @param {String} params.drainId
+ */
+export function disableDrain(params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'put',
+    url: `/v4/drains/organisations/${params.ownerId}/applications/${params.applicationId}/drains/${params.drainId}/disable`,
+    headers: { Accept: 'application/json' },
+    // no body
+  });
+}
+
+/**
+ * PUT /v4/drains/organisations/{ownerId}/applications/{applicationId}/drains/{drainId}/enable
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.applicationId
+ * @param {String} params.drainId
+ */
+export function enableDrain(params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'put',
+    url: `/v4/drains/organisations/${params.ownerId}/applications/${params.applicationId}/drains/${params.drainId}/enable`,
+    headers: { Accept: 'application/json' },
+    // no body
+  });
+}
+
+/**
+ * PATCH /v4/drains/organisations/{ownerId}/applications/{applicationId}/drains/{drainId}/reset-cursor
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.applicationId
+ * @param {String} params.drainId
+ */
+export function resetDrainCursor(params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'patch',
+    url: `/v4/drains/organisations/${params.ownerId}/applications/${params.applicationId}/drains/${params.drainId}/reset-cursor`,
+    headers: { Accept: 'application/json' },
+    // no body
+  });
+}

package/src/clever-client/operators.js

@@ -119,3 +119,19 @@ export function versionUpdate(params, body) {
     body,
   });
 }
+
+/**
+ * GET /v4/addon-providers/addon-otoroshi/addons/{realId}/config.yaml
+ * @param {Object} params
+ * @param {String} params.realId
+ */
+export function getOtoroshiConfig(params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/addon-providers/addon-otoroshi/addons/${params.realId}/config.yaml`,
+    // headers: { Accept: 'application/yaml' },
+    // no queryParams
+    // no body
+  });
+}

package/src/commands/drain.js

@@ -1,108 +1,164 @@
-import { createDrain, deleteDrain, getDrains, updateDrainState } from '@clevercloud/client/esm/api/v2/log.js';
+import { createDrain, deleteDrain, disableDrain, enableDrain, getDrain, getDrains } from '../clever-client/drains.js';
+import { styleText } from '../lib/style-text.js';
 import { Logger } from '../logger.js';
 import * as Application from '../models/application.js';
-import { createDrainBody } from '../models/drain.js';
+import { DRAIN_TYPE_CLI_CODES, DRAIN_TYPES, formatDrain } from '../models/drain.js';
 import { sendToApi } from '../models/send-to-api.js';
 
-// TODO: This could be useful in other commands
-async function getAppOrAddonId({ alias, appIdOrName, addonId }) {
-  return addonId != null ? addonId : await Application.resolveId(appIdOrName, alias).then(({ appId }) => appId);
-}
-
 export async function list(params) {
-  const { alias, app: appIdOrName, addon: addonId, format } = params.options;
+  const { alias, app: appIdOrName, format } = params.options;
+
+  const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
 
-  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
-  const drains = await getDrains({ appId: appIdOrAddonId }).then(sendToApi);
+  const drains = await getDrains({ ownerId, applicationId }).then(sendToApi);
 
   switch (format) {
     case 'json': {
-      const formattedDrains = drains.map((drain) => ({
-        id: drain.id,
-        target: drain.target,
-        state: drain.state,
-      }));
-
-      Logger.printJson(formattedDrains);
+      Logger.printJson(drains);
       break;
     }
     case 'human':
     default: {
       if (drains.length === 0) {
-        Logger.println(`There are no drains for ${appIdOrAddonId}`);
+        Logger.println(`There are no drains for ${applicationId}`);
+        return;
+      }
+
+      if (drains.length === 1) {
+        const formattedDrain = formatDrain(drains[0]);
+        console.table(formattedDrain);
+        return;
       }
 
-      drains.forEach((drain) => {
-        const { id, state, target } = drain;
-        const { url, drainType, indexPrefix, structuredDataParameters } = target;
-
-        let drainView = `${id} -> ${state} for ${url} as ${drainType}`;
-        if (indexPrefix != null) {
-          drainView += `, custom index: '${indexPrefix}-YYYY-MM-DD'`;
-        }
-        if (structuredDataParameters != null) {
-          drainView += `, sd-params: '${structuredDataParameters}'`;
-        }
-        Logger.println(drainView);
+      const formattedDrains = drains.map((drain) => {
+        return {
+          ID: drain.id,
+          Status: drain.status.status,
+          'Execution status': drain.execution.status,
+          URL: drain.recipient.url,
+        };
       });
+
+      console.table(formattedDrains);
     }
   }
 }
 
 export async function create(params) {
-  const [drainTargetType, drainTargetURL] = params.args;
+  const { alias, app: appIdOrName } = params.options;
   const {
-    alias,
-    app: appIdOrName,
-    addon: addonId,
     username,
     password,
     'api-key': apiKey,
     'index-prefix': indexPrefix,
-    'sd-params': structuredDataParameters,
+    'sd-params': rfc5424StructuredDataParameters,
   } = params.options;
-  const drainTargetCredentials = { username, password };
-  const drainTargetConfig = { apiKey, indexPrefix, structuredDataParameters };
-
-  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
-  const body = createDrainBody(
-    appIdOrAddonId,
-    drainTargetURL,
-    drainTargetType,
-    drainTargetCredentials,
-    drainTargetConfig,
-  );
-  await createDrain({ appId: appIdOrAddonId }, body).then(sendToApi);
-
-  Logger.println('Your drain has been successfully saved');
+  const [drainTypeCliCode, url] = params.args;
+
+  const drainType = Object.values(DRAIN_TYPES).find((drainType) => drainType.cliCode === drainTypeCliCode);
+  if (!drainType) {
+    throw new Error(`Invalid drain type. Supported types are: ${DRAIN_TYPE_CLI_CODES.join(', ')}`);
+  }
+
+  const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
+
+  const body = {
+    kind: 'LOG',
+    recipient: {
+      type: drainType.apiCode,
+      url,
+    },
+  };
+
+  if (drainTypeCliCode === DRAIN_TYPES.ELASTICSEARCH.cliCode) {
+    if (!indexPrefix) {
+      throw new Error(`${DRAIN_TYPES.ELASTICSEARCH.cliCode} drains require an index prefix (--index-prefix) to be set`);
+    }
+    if (!url.endsWith('/_bulk')) {
+      throw new Error(`${DRAIN_TYPES.ELASTICSEARCH.cliCode} drain URL must end with '/_bulk'`);
+    }
+    body.recipient.index = indexPrefix;
+  }
+
+  if (drainTypeCliCode === DRAIN_TYPES.ELASTICSEARCH.cliCode || drainTypeCliCode === DRAIN_TYPES.RAW_HTTP.cliCode) {
+    if (username) {
+      body.recipient.username = username;
+    }
+    if (password) {
+      body.recipient.password = password;
+    }
+  }
+
+  if (drainTypeCliCode === DRAIN_TYPES.NEWRELIC.cliCode) {
+    if (!apiKey) {
+      throw new Error(`${DRAIN_TYPES.NEWRELIC.cliCode} drains require an API key (--api-key) to be set`);
+    }
+    body.recipient.apiKey = apiKey;
+  }
+
+  if (
+    drainTypeCliCode === DRAIN_TYPES.OVH_TCP.cliCode ||
+    drainTypeCliCode === DRAIN_TYPES.SYSLOG_TCP.cliCode ||
+    drainTypeCliCode === DRAIN_TYPES.SYSLOG_UDP.cliCode
+  ) {
+    if (rfc5424StructuredDataParameters) {
+      body.recipient.rfc5424StructuredDataParameters = rfc5424StructuredDataParameters;
+    }
+  }
+
+  const drain = await createDrain({ ownerId, applicationId, body }).then(sendToApi);
+  Logger.printSuccess(`Drain ${styleText(['bold', 'green'], drain.id)} has been successfully created and enabled!`);
 }
 
-export async function rm(params) {
+export async function get(params) {
   const [drainId] = params.args;
-  const { alias, app: appIdOrName, addon: addonId } = params.options;
+  const { alias, app: appIdOrName, format } = params.options;
+
+  const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
 
-  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
-  await deleteDrain({ appId: appIdOrAddonId, drainId }).then(sendToApi);
+  const drain = await getDrain({ ownerId, applicationId, drainId }).then(sendToApi);
 
-  Logger.println('Your drain has been successfully removed');
+  switch (format) {
+    case 'json': {
+      Logger.printJson(drain);
+      break;
+    }
+    case 'human':
+    default: {
+      const formattedDrain = formatDrain(drain);
+      console.table(formattedDrain);
+    }
+  }
+}
+
+export async function remove(params) {
+  const [drainId] = params.args;
+  const { alias, app: appIdOrName } = params.options;
+
+  const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
+
+  await deleteDrain({ ownerId, applicationId, drainId }).then(sendToApi);
+  Logger.printSuccess(`Drain ${styleText(['bold', 'green'], drainId)} has been successfully removed!`);
 }
 
 export async function enable(params) {
   const [drainId] = params.args;
-  const { alias, app: appIdOrName, addon: addonId } = params.options;
+  const { alias, app: appIdOrName } = params.options;
 
-  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
-  await updateDrainState({ appId: appIdOrAddonId, drainId }, { state: 'ENABLED' }).then(sendToApi);
+  const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
 
-  Logger.println('Your drain has been enabled');
+  await enableDrain({ ownerId, applicationId, drainId }).then(sendToApi);
+
+  Logger.printSuccess(`Drain ${styleText(['bold', 'green'], drainId)} has been successfully enabled!`);
 }
 
 export async function disable(params) {
   const [drainId] = params.args;
-  const { alias, app: appIdOrName, addon: addonId } = params.options;
+  const { alias, app: appIdOrName } = params.options;
+
+  const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
 
-  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
-  await updateDrainState({ appId: appIdOrAddonId, drainId }, { state: 'DISABLED' }).then(sendToApi);
+  await disableDrain({ ownerId, applicationId, drainId }).then(sendToApi);
 
-  Logger.println('Your drain has been disabled');
+  Logger.printSuccess(`Drain ${styleText(['bold', 'green'], drainId)} has been successfully disabled!`);
 }

package/src/commands/otoroshi.js

@@ -50,6 +50,18 @@ export async function get(params) {
   await operatorPrint('otoroshi', addonIdOrName, format);
 }
 
+/**
+ * Print the configuration of an Otoroshi operator in otoroshictl format
+ * @param {object} params The command's parameters
+ * @param {string} params.args[0] The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function getConfig(params) {
+  const [addonIdOrName] = params.args;
+  const { format } = params.options;
+  await operatorPrint('otoroshi', addonIdOrName, 'otoroshictl');
+}
+
 /**
  * List all Otoroshi operators
  * @returns {Promise<void>}

package/src/lib/operator-commands.js

@@ -1,6 +1,7 @@
 import dedent from 'dedent';
 import _ from 'lodash';
 import {
+  getOtoroshiConfig,
   ngDisableOperator,
   ngEnableOperator,
   rebootOperator,
@@ -249,6 +250,13 @@ export async function operatorRebuild(provider, addonIdOrName) {
 export async function operatorPrint(provider, addonIdOrName, format = 'human') {
   const operator = await Operator.getDetails(provider, addonIdOrName);
 
+  if (provider === 'otoroshi' && format === 'otoroshictl') {
+    const config = await getOtoroshiConfig({ realId: operator.resourceId }).then(sendToApi);
+
+    Logger.println(config);
+    return;
+  }
+
   const dataToPrint = {
     Name: operator.name,
     ID: operator.resourceId,

package/src/models/drain.js

@@ -1,133 +1,29 @@
-import cliparse from 'cliparse';
-
-const DRAIN_TYPES = [
-  { id: 'TCPSyslog', structuredDataParameters: 'OPTIONAL' },
-  { id: 'UDPSyslog', structuredDataParameters: 'OPTIONAL' },
-  { id: 'HTTP', credentials: 'OPTIONAL' },
-  { id: 'ElasticSearch', credentials: 'MANDATORY', indexPrefix: 'OPTIONAL' },
-  { id: 'DatadogHTTP' },
-  { id: 'NewRelicHTTP', apiKey: 'MANDATORY' },
-];
-
-export function createDrainBody(appId, drainTargetURL, drainTargetType, drainTargetCredentials, drainTargetConfig) {
-  if (!authorizeDrainCreation(drainTargetType, drainTargetCredentials, drainTargetConfig)) {
-    throw new Error(
-      "Credentials are: optional for HTTP, mandatory for ElasticSearch, NewRelicHTTP and TCPSyslog/UDPSyslog don't need them.",
-    );
-  }
-
-  const body = {
-    url: drainTargetURL,
-    drainType: drainTargetType,
-  };
-  if (credentialsExist(drainTargetCredentials)) {
-    body.credentials = {
-      username: drainTargetCredentials.username || '',
-      password: drainTargetCredentials.password || '',
-    };
-  }
-  if (keyExist(drainTargetConfig)) {
-    body.APIKey = drainTargetConfig.apiKey;
-  }
-  if (indexPrefixExist(drainTargetConfig)) {
-    body.indexPrefix = drainTargetConfig.indexPrefix;
-  }
-  if (structuredDataParametersExist(drainTargetConfig)) {
-    body.structuredDataParameters = drainTargetConfig.structuredDataParameters;
-  }
-  return body;
-}
-
-export function authorizeDrainCreation(drainTargetType, drainTargetCredentials, drainTargetConfig) {
-  if (drainTypeExists(drainTargetType)) {
-    // retrieve field for drain type ('mandatory', 'optional', undefined)
-    const credStatus = fieldStatus(drainTargetType).credentials;
-    const keyStatus = fieldStatus(drainTargetType).apiKey;
-    const indexPrefixStatus = fieldStatus(drainTargetType).indexPrefix;
-    const structuredDataParametersStatus = fieldStatus(drainTargetType).structuredDataParameters;
-
-    if (credStatus === 'MANDATORY') {
-      return credentialsExist(drainTargetCredentials);
-    }
-    if (credStatus === 'OPTIONAL') {
-      return true;
-    }
-    if (!credStatus && !keyStatus) {
-      return credentialsEmpty(drainTargetCredentials);
-    }
-
-    if (keyStatus === 'MANDATORY') {
-      return keyExist(drainTargetConfig);
-    }
-    if (keyStatus === 'OPTIONAL') {
-      return true;
-    }
-    if (!keyStatus) {
-      return keyEmpty(drainTargetConfig);
-    }
-
-    if (indexPrefixStatus === 'MANDATORY') {
-      return indexPrefixExist(drainTargetConfig);
-    }
-    if (indexPrefixStatus === 'OPTIONAL') {
-      return true;
-    }
-    if (!indexPrefixStatus) {
-      return indexPrefixEmpty(drainTargetConfig);
-    }
-
-    if (structuredDataParametersStatus === 'MANDATORY') {
-      return structuredDataParametersExist(drainTargetConfig);
-    }
-    if (structuredDataParametersStatus === 'OPTIONAL') {
-      return true;
-    }
-    if (!structuredDataParametersStatus) {
-      return structuredDataParametersEmpty(drainTargetConfig);
-    }
-  }
-}
-
-function fieldStatus(drainTargetType) {
-  return DRAIN_TYPES.find(({ id }) => id === drainTargetType);
-}
-
-function drainTypeExists(drainTargetType) {
-  return DRAIN_TYPES.some(({ id }) => id === drainTargetType);
-}
-
-function credentialsExist({ username, password }) {
-  return username != null && password != null;
-}
-
-function credentialsEmpty({ username, password }) {
-  return username == null && password == null;
-}
-
-function indexPrefixExist({ indexPrefix }) {
-  return indexPrefix != null;
-}
-
-function indexPrefixEmpty({ indexPrefix }) {
-  return indexPrefix == null;
-}
-
-function structuredDataParametersExist({ structuredDataParameters }) {
-  return structuredDataParameters != null;
-}
-
-function structuredDataParametersEmpty({ structuredDataParameters }) {
-  return structuredDataParameters == null;
-}
-
-function keyExist({ apiKey }) {
-  return apiKey != null;
-}
-
-function keyEmpty({ apiKey }) {
-  return apiKey == null;
-}
-
-export function listDrainTypes() {
-  return cliparse.autocomplete.words(DRAIN_TYPES.map((type) => type.id));
+export const DRAIN_TYPES = {
+  DATADOG: { apiCode: 'DATADOG', cliCode: 'datadog', label: 'Datadog' },
+  ELASTICSEARCH: { apiCode: 'ELASTICSEARCH', cliCode: 'elasticsearch', label: 'Elasticsearch' },
+  NEWRELIC: { apiCode: 'NEWRELIC', cliCode: 'newrelic', label: 'New Relic' },
+  OVH_TCP: { apiCode: 'OVH_TCP', cliCode: 'ovh-tcp', label: 'OVH TCP' },
+  RAW_HTTP: { apiCode: 'RAW_HTTP', cliCode: 'raw-http', label: 'Raw HTTP' },
+  SYSLOG_TCP: { apiCode: 'SYSLOG_TCP', cliCode: 'syslog-tcp', label: 'Syslog TCP' },
+  SYSLOG_UDP: { apiCode: 'SYSLOG_UDP', cliCode: 'syslog-udp', label: 'Syslog UDP' },
+};
+
+export const DRAIN_TYPE_CLI_CODES = Object.values(DRAIN_TYPES).map(({ cliCode }) => cliCode);
+
+export function formatDrain(rawDrain) {
+  const drainType = DRAIN_TYPES[rawDrain.recipient.type];
+  const drainDetails = [
+    ['ID', rawDrain.id],
+    ['Status', rawDrain.status.status],
+    ['Execution status', rawDrain.execution.status],
+    ['URL', rawDrain.recipient.url],
+    ['Type', drainType.label],
+    ['Custom index', rawDrain.recipient.index],
+    ['SD parameters', rawDrain.recipient.rfc5424StructuredDataParameters],
+    ['Message output rate', Math.floor(rawDrain.backlog.msgRateOut * 60) + ' messages/minute'],
+    ['Message throughput', Math.floor(rawDrain.backlog.msgRateOut) + ' bytes/second'],
+    ['Backlog', rawDrain.backlog.msgBacklog + ' pending messages'],
+    ['Last error', rawDrain.execution.lastError],
+  ];
+  return Object.fromEntries(drainDetails.filter(([_name, value]) => value != null));
 }