clever-tools 4.4.1 → 4.5.0

package/src/commands/domain/domain.overview.command.js

@@ -0,0 +1,157 @@
+import { getAllDomains } from '@clevercloud/client/esm/api/v2/application.js';
+import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
+import _ from 'lodash';
+import { parse as parseDomain } from 'tldts';
+import { z } from 'zod';
+import { defineCommand } from '../../lib/define-command.js';
+import { defineOption } from '../../lib/define-option.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { humanJsonOutputFormatOption } from '../global.options.js';
+
+function recursiveSort(obj) {
+  if (typeof obj === 'object' && obj.appId != null) {
+    return obj;
+  }
+
+  const sortedObj = {};
+  Object.keys(obj)
+    .sort((a, b) => {
+      // if the domain contains a wildcard, we want it to be the first of subdomains
+      const aWithReplacedWildcard = a.replace(/^\*/, 'a');
+      const bWithReplacedWildcard = b.replace(/^\*/, 'a');
+      return aWithReplacedWildcard.localeCompare(bWithReplacedWildcard);
+    })
+    .forEach((key) => {
+      sortedObj[key] = recursiveSort(obj[key]);
+    });
+
+  return sortedObj;
+}
+
+function recursiveDisplay(obj, indentLevel = 0) {
+  if (typeof obj === 'object' && obj.appId != null) {
+    Logger.printlnWithIndent(`${obj.ownerName} | ${obj.appName} (${obj.appVariantSlug})`, indentLevel);
+    Logger.printlnWithIndent(styleText('blue', obj.appConsoleUrl), indentLevel);
+    return;
+  }
+
+  for (const [propertyPath, subObj] of Object.entries(obj)) {
+    if (propertyPath !== '/') {
+      Logger.println('');
+      Logger.printlnWithIndent(styleText('yellow', propertyPath), indentLevel);
+      recursiveDisplay(subObj, indentLevel + 2);
+    } else {
+      recursiveDisplay(subObj, indentLevel);
+    }
+  }
+}
+
+export const domainOverviewCommand = defineCommand({
+  description: 'Get an overview of all your domains (all orgas, all apps)',
+  since: '3.9.0',
+  options: {
+    filter: defineOption({
+      name: 'filter',
+      schema: z.string().default(''),
+      description: 'Get only domains containing the provided text',
+      placeholder: 'text',
+    }),
+    format: humanJsonOutputFormatOption,
+  },
+  args: [],
+  async handler(options) {
+    const { format, filter } = options;
+
+    const summary = await getSummary().then(sendToApi);
+    const consoleUrl = summary.user.partnerConsoleUrl;
+
+    const applications = [
+      ...summary.user.applications.map((app) => {
+        return { ownerName: summary.user.name, ownerId: summary.user.id, ...app };
+      }),
+      ...summary.organisations.flatMap((o) => {
+        return o.applications.map((app) => {
+          return { ownerName: o.name, ownerId: o.id, ...app };
+        });
+      }),
+    ];
+
+    const applicationsWithDomains = await Promise.all(
+      applications.map(async (app) => {
+        const domains = await getAllDomains({ id: app.ownerId, appId: app.id })
+          .then(sendToApi)
+          .catch((error) => {
+            // if the user cannot access application domains, we simply act as if there were no domains
+            if (error?.response?.status === 403) {
+              Logger.printErrorLine(`You cannot list domains for application ${app.name} (${app.id})`);
+              return [];
+            }
+            throw error;
+          });
+        return { app, domains };
+      }),
+    );
+
+    const applicationsWithParsedDomain = applicationsWithDomains.flatMap(({ app, domains }) => {
+      return domains
+        .filter((domain) => filter == null || domain.fqdn.includes(filter))
+        .map((domain) => {
+          // `validateHostname` is set to `false` so that wildcard domains may be parsed correctly
+          const parsedDomain = parseDomain(domain.fqdn, { validateHostname: false });
+          const pathname = new URL('https://' + domain.fqdn).pathname;
+          const subdomains = parsedDomain.subdomain !== '' ? parsedDomain.subdomain.split('.') : [];
+
+          // We're trying to create a propertyPath for lodash to create a tree structure object,
+          // the propertyPath for `aaa.bbb.ccc.example.com/the-path` would be:
+          // ["example.com", "example.com.ccc", "example.com.ccc.bbb", "example.com.ccc.bbb.aaa", "/path-aaa"]",
+
+          const sortSegments = [parsedDomain.domain, ...subdomains.reverse()];
+          const propertyPath = sortSegments.map((item, i, all) => {
+            return all
+              .slice(0, i + 1)
+              .reverse()
+              .join('.');
+          });
+          propertyPath.push(pathname);
+
+          return {
+            ownerId: app.ownerId,
+            ownerName: app.ownerName,
+            appId: app.id,
+            appName: app.name,
+            appConsoleUrl: `${consoleUrl}/goto/${app.id}`,
+            appVariantSlug: app.variantSlug,
+            domain: domain.fqdn,
+            propetyPath: propertyPath,
+          };
+        });
+    });
+
+    const applicationsWithParsedDomainAsTree = {};
+    for (const { propetyPath, ...appWithDomain } of applicationsWithParsedDomain) {
+      _.set(applicationsWithParsedDomainAsTree, propetyPath, appWithDomain);
+    }
+
+    const applicationsWithParsedDomainAsSortedTree = recursiveSort(applicationsWithParsedDomainAsTree);
+
+    switch (format) {
+      case 'json':
+        Logger.printJson(applicationsWithParsedDomainAsSortedTree);
+        break;
+      case 'human':
+      default:
+        if (Object.keys(applicationsWithParsedDomainAsSortedTree).length === 0) {
+          if (filter?.length > 0) {
+            Logger.println(`No matches for filter "${filter}"`);
+          } else {
+            Logger.println('No domains');
+          }
+        } else {
+          recursiveDisplay(applicationsWithParsedDomainAsSortedTree);
+        }
+        break;
+    }
+  },
+});

package/src/commands/domain/domain.rm.command.js

@@ -0,0 +1,25 @@
+import { removeDomain } from '@clevercloud/client/esm/api/v2/application.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { Logger } from '../../logger.js';
+import * as Application from '../../models/application.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+import { fqdnArg } from './domain.args.js';
+
+export const domainRmCommand = defineCommand({
+  description: 'Remove a domain name from an application',
+  since: '0.2.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [fqdnArg],
+  async handler(options, fqdn) {
+    const { alias, app: appIdOrName } = options;
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+    const encodedFqdn = encodeURIComponent(fqdn);
+
+    await removeDomain({ id: ownerId, appId, domain: encodedFqdn }).then(sendToApi);
+    Logger.println('Your domain has been successfully removed');
+  },
+});

package/src/commands/drain/drain.args.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { defineArgument } from '../../lib/define-argument.js';
+
+export const drainIdArg = defineArgument({
+  schema: z.string(),
+  description: 'Drain ID',
+  placeholder: 'drain-id',
+});

package/src/commands/drain/drain.command.js

@@ -0,0 +1,56 @@
+import { getDrains } from '../../clever-client/drains.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { Logger } from '../../logger.js';
+import * as Application from '../../models/application.js';
+import { formatDrain } from '../../models/drain.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { aliasOption, appIdOrNameOption, humanJsonOutputFormatOption } from '../global.options.js';
+
+export const drainCommand = defineCommand({
+  description: 'Manage drains',
+  since: '0.9.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+    format: humanJsonOutputFormatOption,
+  },
+  args: [],
+  async handler(options) {
+    const { alias, app: appIdOrName, format } = options;
+
+    const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
+
+    const drains = await getDrains({ ownerId, applicationId }).then(sendToApi);
+
+    switch (format) {
+      case 'json': {
+        Logger.printJson(drains);
+        break;
+      }
+      case 'human':
+      default: {
+        if (drains.length === 0) {
+          Logger.println(`There are no drains for ${applicationId}`);
+          return;
+        }
+
+        if (drains.length === 1) {
+          const formattedDrain = formatDrain(drains[0]);
+          console.table(formattedDrain);
+          return;
+        }
+
+        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);
+      }
+    }
+  },
+});

package/src/commands/drain/drain.create.command.js

@@ -0,0 +1,128 @@
+import { z } from 'zod';
+import { createDrain } from '../../clever-client/drains.js';
+import { defineArgument } from '../../lib/define-argument.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { defineOption } from '../../lib/define-option.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import * as Application from '../../models/application.js';
+import { DRAIN_TYPE_CLI_CODES, DRAIN_TYPES } from '../../models/drain.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+
+export const drainCreateCommand = defineCommand({
+  description: 'Create a drain',
+  since: '0.9.0',
+  options: {
+    username: defineOption({
+      name: 'username',
+      schema: z.string().optional(),
+      description: 'Basic auth username (for elasticsearch or raw-http)',
+      aliases: ['u'],
+      placeholder: 'username',
+    }),
+    password: defineOption({
+      name: 'password',
+      schema: z.string().optional(),
+      description: 'Basic auth password (for elasticsearch or raw-http)',
+      aliases: ['p'],
+      placeholder: 'password',
+    }),
+    apiKey: defineOption({
+      name: 'api-key',
+      schema: z.string().optional(),
+      description: 'API key (for newrelic)',
+      aliases: ['k'],
+      placeholder: 'api-key',
+    }),
+    indexPrefix: defineOption({
+      name: 'index-prefix',
+      schema: z.string().optional(),
+      description: 'Optional index prefix (for elasticsearch), `logstash` value is used if not set',
+      aliases: ['i'],
+      placeholder: 'index-prefix',
+    }),
+    rfc5424StructuredDataParameters: defineOption({
+      name: 'sd-params',
+      schema: z.string().optional(),
+      description: 'RFC5424 structured data parameters (for ovh-tcp), e.g.: `X-OVH-TOKEN=\\\"REDACTED\\\"`',
+      aliases: ['s'],
+      placeholder: 'sd-params',
+    }),
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [
+    defineArgument({
+      schema: z.string(),
+      description: 'No description available',
+      placeholder: 'drain-type',
+      complete: DRAIN_TYPE_CLI_CODES,
+    }),
+    defineArgument({
+      schema: z.string(),
+      description: 'Drain URL',
+      placeholder: 'drain-url',
+    }),
+  ],
+  async handler(options, drainTypeCliCode, url) {
+    const { alias, app: appIdOrName } = options;
+    const { username, password, apiKey, indexPrefix, rfc5424StructuredDataParameters } = options;
+
+    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!`);
+  },
+});

package/src/commands/drain/drain.disable.command.js

@@ -0,0 +1,27 @@
+import { disableDrain } from '../../clever-client/drains.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import * as Application from '../../models/application.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+import { drainIdArg } from './drain.args.js';
+
+export const drainDisableCommand = defineCommand({
+  description: 'Disable a drain',
+  since: '0.9.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [drainIdArg],
+  async handler(options, drainId) {
+    const { alias, app: appIdOrName } = options;
+
+    const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
+
+    await disableDrain({ ownerId, applicationId, drainId }).then(sendToApi);
+
+    Logger.printSuccess(`Drain ${styleText(['bold', 'green'], drainId)} has been successfully disabled!`);
+  },
+});

package/src/commands/drain/drain.docs.md

@@ -0,0 +1,129 @@
+# 📖 `clever drain` command reference
+
+## ➡️ `clever drain` <kbd>Since 0.9.0</kbd>
+
+Manage drains
+
+```bash
+clever drain [options]
+```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Short name for the application|
+|`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|
+|`-F`, `--format` `<format>`|Output format (human, json) (default: human)|
+
+## ➡️ `clever drain create` <kbd>Since 0.9.0</kbd>
+
+Create a drain
+
+```bash
+clever drain create <drain-type> <drain-url> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`drain-type`|No description available|
+|`drain-url`|Drain URL|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Short name for the application|
+|`-k`, `--api-key` `<api-key>`|API key (for newrelic)|
+|`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|
+|`-i`, `--index-prefix` `<index-prefix>`|Optional index prefix (for elasticsearch), `logstash` value is used if not set|
+|`-p`, `--password` `<password>`|Basic auth password (for elasticsearch or raw-http)|
+|`-s`, `--sd-params` `<sd-params>`|RFC5424 structured data parameters (for ovh-tcp), e.g.: `X-OVH-TOKEN=\"REDACTED\"`|
+|`-u`, `--username` `<username>`|Basic auth username (for elasticsearch or raw-http)|
+
+## ➡️ `clever drain disable` <kbd>Since 0.9.0</kbd>
+
+Disable a drain
+
+```bash
+clever drain disable <drain-id> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`drain-id`|Drain ID|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Short name for the application|
+|`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|
+
+## ➡️ `clever drain enable` <kbd>Since 0.9.0</kbd>
+
+Enable a drain
+
+```bash
+clever drain enable <drain-id> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`drain-id`|Drain ID|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Short name for the application|
+|`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|
+
+## ➡️ `clever drain get` <kbd>Since 0.9.0</kbd>
+
+Get drain info
+
+```bash
+clever drain get <drain-id> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`drain-id`|Drain ID|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Short name for the application|
+|`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|
+|`-F`, `--format` `<format>`|Output format (human, json) (default: human)|
+
+## ➡️ `clever drain remove` <kbd>Since 0.9.0</kbd>
+
+Remove a drain
+
+```bash
+clever drain remove <drain-id> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`drain-id`|Drain ID|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Short name for the application|
+|`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|

package/src/commands/drain/drain.enable.command.js

@@ -0,0 +1,27 @@
+import { enableDrain } from '../../clever-client/drains.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import * as Application from '../../models/application.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+import { drainIdArg } from './drain.args.js';
+
+export const drainEnableCommand = defineCommand({
+  description: 'Enable a drain',
+  since: '0.9.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [drainIdArg],
+  async handler(options, drainId) {
+    const { alias, app: appIdOrName } = options;
+
+    const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
+
+    await enableDrain({ ownerId, applicationId, drainId }).then(sendToApi);
+
+    Logger.printSuccess(`Drain ${styleText(['bold', 'green'], drainId)} has been successfully enabled!`);
+  },
+});

package/src/commands/drain/drain.get.command.js

@@ -0,0 +1,38 @@
+import { getDrain } from '../../clever-client/drains.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { Logger } from '../../logger.js';
+import * as Application from '../../models/application.js';
+import { formatDrain } from '../../models/drain.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { aliasOption, appIdOrNameOption, humanJsonOutputFormatOption } from '../global.options.js';
+import { drainIdArg } from './drain.args.js';
+
+export const drainGetCommand = defineCommand({
+  description: 'Get drain info',
+  since: '0.9.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+    format: humanJsonOutputFormatOption,
+  },
+  args: [drainIdArg],
+  async handler(options, drainId) {
+    const { alias, app: appIdOrName, format } = options;
+
+    const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
+
+    const drain = await getDrain({ ownerId, applicationId, drainId }).then(sendToApi);
+
+    switch (format) {
+      case 'json': {
+        Logger.printJson(drain);
+        break;
+      }
+      case 'human':
+      default: {
+        const formattedDrain = formatDrain(drain);
+        console.table(formattedDrain);
+      }
+    }
+  },
+});

package/src/commands/drain/drain.remove.command.js

@@ -0,0 +1,26 @@
+import { deleteDrain } from '../../clever-client/drains.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import * as Application from '../../models/application.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+import { drainIdArg } from './drain.args.js';
+
+export const drainRemoveCommand = defineCommand({
+  description: 'Remove a drain',
+  since: '0.9.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [drainIdArg],
+  async handler(options, drainId) {
+    const { alias, app: appIdOrName } = 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!`);
+  },
+});

package/src/commands/emails/emails.add.command.js

@@ -0,0 +1,32 @@
+import { todo_addEmailAddress as addEmailAddress } from '@clevercloud/client/esm/api/v2/user.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { Logger } from '../../logger.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { emailArg } from './emails.args.js';
+
+export const emailsAddCommand = defineCommand({
+  description: 'Add a new secondary email address to the current user',
+  since: '3.13.0',
+  options: {},
+  args: [emailArg],
+  async handler(_options, secondaryAddress) {
+    const secondaryAddressEncoded = encodeURIComponent(secondaryAddress);
+    try {
+      await addEmailAddress({ email: secondaryAddressEncoded }).then(sendToApi);
+      Logger.printSuccess(
+        `The server sent a confirmation email to ${secondaryAddress} to validate your secondary address`,
+      );
+    } catch (e) {
+      switch (e?.responseBody?.id) {
+        case 101:
+          throw new Error('This address already belongs to your account');
+        case 550:
+          throw new Error('The format of this address is invalid');
+        case 1004:
+          throw new Error('This address belongs to another account');
+        default:
+          throw e;
+      }
+    }
+  },
+});

package/src/commands/emails/emails.args.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { defineArgument } from '../../lib/define-argument.js';
+
+export const emailArg = defineArgument({
+  schema: z.string().email(),
+  description: 'Email address',
+  placeholder: 'email',
+});