clever-tools 4.4.0 → 4.5.0

package/src/commands/applications/applications.command.js

@@ -0,0 +1,59 @@
+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 * as AppConfig from '../../models/app_configuration.js';
+
+function formatApps(apps, onlyAliases, json) {
+  if (json) {
+    if (onlyAliases) {
+      apps = apps.map((a) => a.alias);
+    }
+    return JSON.stringify(apps, null, 2);
+  } else {
+    if (onlyAliases) {
+      return apps.map((a) => a.alias).join('\n');
+    } else {
+      return apps
+        .map((app) => {
+          const sshUrl = app.git_ssh_url ?? app.deploy_url.replace('https://', 'git+ssh://git@');
+          return [
+            `Application ${app.name}`,
+            `  alias: ${styleText('bold', app.alias)}`,
+            `  ID: ${app.app_id}`,
+            `  deployment URL: ${app.deploy_url}`,
+            `  git+ssh URL: ${sshUrl}`,
+          ].join('\n');
+        })
+        .join('\n\n');
+    }
+  }
+}
+
+export const applicationsCommand = defineCommand({
+  description: 'List linked applications',
+  since: '0.3.0',
+  options: {
+    onlyAliases: defineOption({
+      name: 'only-aliases',
+      schema: z.boolean().default(false),
+      description: 'List only application aliases',
+    }),
+    json: defineOption({
+      name: 'json',
+      schema: z.boolean().default(false),
+      description: 'Show result in JSON format',
+      aliases: ['j'],
+    }),
+  },
+  args: [],
+  async handler(options) {
+    const { onlyAliases, json } = options;
+
+    const { apps } = await AppConfig.loadApplicationConf();
+
+    const formattedApps = formatApps(apps, onlyAliases, json);
+    Logger.println(formattedApps);
+  },
+});

package/src/commands/applications/applications.docs.md

@@ -0,0 +1,31 @@
+# 📖 `clever applications` command reference
+
+## ➡️ `clever applications` <kbd>Since 0.3.0</kbd>
+
+List linked applications
+
+```bash
+clever applications [options]
+```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-j`, `--json`|Show result in JSON format|
+|`--only-aliases`|List only application aliases|
+
+## ➡️ `clever applications list` <kbd>Since 3.8.0</kbd>
+
+List all applications
+
+```bash
+clever applications list [options]
+```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-F`, `--format` `<format>`|Output format (human, json) (default: human)|
+|`-o`, `--org`, `--owner` `<org-id\|org-name>`|Organisation to target by its ID (or name, if unambiguous)|

package/src/commands/applications/applications.list.command.js

@@ -0,0 +1,100 @@
+import { formatTable } from '../../format-table.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { styleText } from '../../lib/style-text.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 { truncateWithEllipsis } from '../../models/utils.js';
+import { humanJsonOutputFormatOption, orgaIdOrNameOption } from '../global.options.js';
+
+function getPropertyMaxWidth(array, propertyName) {
+  return Math.max(...array.map((o) => o[propertyName].length));
+}
+
+export const applicationsListCommand = defineCommand({
+  description: 'List all applications',
+  since: '3.8.0',
+  options: {
+    org: orgaIdOrNameOption,
+    format: humanJsonOutputFormatOption,
+  },
+  args: [],
+  async handler(options) {
+    const { org: orgaIdOrName, format } = options;
+
+    const linkedApps = await AppConfig.loadApplicationConf().then((conf) => conf.apps);
+
+    const ownerId =
+      orgaIdOrName != null && orgaIdOrName.orga_name !== '' ? await Organisation.getId(orgaIdOrName) : null;
+
+    const allAppsPerOrg = await Application.getAllApps(ownerId);
+
+    // For each app, we try to find a corresponding local alias in the configuration file
+    const allAppsWithAliasPerOrg = allAppsPerOrg.map((org) => {
+      const applicationsWithAlias = org.applications.map((app) => {
+        const foundAlias = linkedApps.find((a) => a.app_id === app.app_id)?.alias;
+        return { ...app, alias: foundAlias ?? '' };
+      });
+      return { ...org, applications: applicationsWithAlias };
+    });
+
+    switch (format) {
+      case 'json': {
+        Logger.printJson(allAppsWithAliasPerOrg);
+        break;
+      }
+      case 'human':
+      default: {
+        const headers = ['APPLICATION ID', 'NAME', 'TYPE', 'ZONE', 'LOCAL ALIAS'];
+        const appNameWidth = 42;
+
+        // We calculate the maximum width of each column to format the table
+        const allApps = allAppsWithAliasPerOrg.flatMap((org) => org.applications);
+        const columnWidths = [
+          getPropertyMaxWidth(allApps, 'app_id'),
+          appNameWidth,
+          getPropertyMaxWidth(allApps, 'type'),
+          getPropertyMaxWidth(allApps, 'zone'),
+          getPropertyMaxWidth(allApps, 'alias'),
+        ];
+
+        allAppsWithAliasPerOrg.forEach((org) => {
+          Logger.println();
+
+          const applicationsPlural = org.applications.length !== 1 ? 'applications' : 'application';
+          const punctuation = org.applications.length > 0 ? ':' : '';
+
+          Logger.println(
+            styleText(
+              'blue',
+              `• Organization '${org.name}' (${org.id}) with ${org.applications.length} ${applicationsPlural}${punctuation}`,
+            ),
+          );
+
+          if (org.applications.length > 0) {
+            Logger.println();
+            Logger.println(
+              formatTable(
+                [
+                  headers,
+                  ...org.applications.map((app) => [
+                    app.app_id,
+                    truncateWithEllipsis(appNameWidth, app.name),
+                    app.type,
+                    app.zone,
+                    app.alias,
+                  ]),
+                ],
+
+                columnWidths,
+              ),
+            );
+          }
+        });
+
+        break;
+      }
+    }
+  },
+});

package/src/commands/cancel-deploy/cancel-deploy.command.js

@@ -0,0 +1,30 @@
+import { cancelDeployment, getAllDeployments } from '@clevercloud/client/esm/api/v2/application.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';
+
+export const cancelDeployCommand = defineCommand({
+  description: 'Cancel an ongoing deployment',
+  since: '0.2.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [],
+  async handler(options) {
+    const { alias, app: appIdOrName } = 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') {
+      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 ${styleText(['bold', 'green'], deployments[0].uuid)} successfully cancelled!`);
+  },
+});

package/src/commands/cancel-deploy/cancel-deploy.docs.md

@@ -0,0 +1,16 @@
+# 📖 `clever cancel-deploy` command reference
+
+## ➡️ `clever cancel-deploy` <kbd>Since 0.2.0</kbd>
+
+Cancel an ongoing deployment
+
+```bash
+clever cancel-deploy [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)|

package/src/commands/config/config.args.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { defineArgument } from '../../lib/define-argument.js';
+import { listAvailableIds } from '../../models/application_configuration.js';
+
+export const configurationNameArg = defineArgument({
+  schema: z.string(),
+  description: `Configuration to manage: ${listAvailableIds(true)}`,
+  placeholder: 'configuration-name',
+  complete: listAvailableIds,
+});

package/src/commands/config/config.command.js

@@ -0,0 +1,20 @@
+import { defineCommand } from '../../lib/define-command.js';
+import * as Application from '../../models/application.js';
+import * as ApplicationConfiguration from '../../models/application_configuration.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+
+export const configCommand = defineCommand({
+  description: 'Display or edit the configuration of your application',
+  since: '2.5.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [],
+  async handler(options) {
+    const { alias, app: appIdOrName } = options;
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+    const app = await Application.get(ownerId, appId);
+    ApplicationConfiguration.printAllValues(app);
+  },
+});

package/src/commands/config/config.docs.md

@@ -0,0 +1,86 @@
+# 📖 `clever config` command reference
+
+## ➡️ `clever config` <kbd>Since 2.5.0</kbd>
+
+Display or edit the configuration of your application
+
+```bash
+clever config [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)|
+
+## ➡️ `clever config get` <kbd>Since 2.5.0</kbd>
+
+Display the current configuration
+
+```bash
+clever config get <configuration-name> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`configuration-name`|Configuration to manage: name, description, zero-downtime, sticky-sessions, cancel-on-push, force-https, or task|
+
+### ⚙️ 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 config set` <kbd>Since 2.5.0</kbd>
+
+Edit one configuration setting
+
+```bash
+clever config set <configuration-name> <configuration-value> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`configuration-name`|Configuration to manage: name, description, zero-downtime, sticky-sessions, cancel-on-push, force-https, or task|
+|`configuration-value`|The new value of the configuration|
+
+### ⚙️ 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 config update` <kbd>Since 2.5.0</kbd>
+
+Edit multiple configuration settings at once
+
+```bash
+clever config update [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)|
+|`--description` `<description>`|Set application description|
+|`--disable-cancel-on-push`|Disable cancel on push|
+|`--disable-force-https`|Disable force HTTPS redirection|
+|`--disable-sticky-sessions`|Disable sticky sessions|
+|`--disable-task`|Disable application as Clever Task|
+|`--disable-zero-downtime`|Disable zero-downtime deployment|
+|`--enable-cancel-on-push`|Enable cancel on push|
+|`--enable-force-https`|Enable force HTTPS redirection|
+|`--enable-sticky-sessions`|Enable sticky sessions|
+|`--enable-task`|Enable application as Clever Task|
+|`--enable-zero-downtime`|Enable zero-downtime deployment|
+|`--name` `<name>`|Set application name|

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

@@ -0,0 +1,21 @@
+import { defineCommand } from '../../lib/define-command.js';
+import * as Application from '../../models/application.js';
+import * as ApplicationConfiguration from '../../models/application_configuration.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+import { configurationNameArg } from './config.args.js';
+
+export const configGetCommand = defineCommand({
+  description: 'Display the current configuration',
+  since: '2.5.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [configurationNameArg],
+  async handler(options, configurationName) {
+    const { alias, app: appIdOrName } = options;
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+    const app = await Application.get(ownerId, appId);
+    ApplicationConfiguration.printValue(app, configurationName);
+  },
+});

package/src/commands/config/config.set.command.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { defineArgument } from '../../lib/define-argument.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 * as ApplicationConfiguration from '../../models/application_configuration.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+import { configurationNameArg } from './config.args.js';
+
+export const configSetCommand = defineCommand({
+  description: 'Edit one configuration setting',
+  since: '2.5.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [
+    configurationNameArg,
+    defineArgument({
+      schema: z.string(),
+      description: 'The new value of the configuration',
+      placeholder: 'configuration-value',
+    }),
+  ],
+  async handler(options, configurationName, configurationValue) {
+    const { alias, app: appIdOrName } = options;
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+    const config = ApplicationConfiguration.getById(configurationName);
+    const newOptions = {
+      [config.name]: ApplicationConfiguration.parse(config, configurationValue),
+    };
+    const app = await Application.updateOptions(ownerId, appId, newOptions);
+    Logger.printSuccess(
+      `Config ${styleText('green', config.id)} successfully updated to ${styleText('green', ApplicationConfiguration.formatValue(config, app[config.name]).toString())}!`,
+    );
+  },
+});

package/src/commands/config/config.update.command.js

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { defineCommand } from '../../lib/define-command.js';
+import { defineOption } from '../../lib/define-option.js';
+import * as Application from '../../models/application.js';
+import * as ApplicationConfiguration from '../../models/application_configuration.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+
+export const configUpdateCommand = defineCommand({
+  description: 'Edit multiple configuration settings at once',
+  since: '2.5.0',
+  options: {
+    alias: aliasOption,
+    appIdOrName: appIdOrNameOption,
+    name: defineOption({
+      name: 'name',
+      schema: z.string().optional(),
+      description: 'Set application name',
+    }),
+    description: defineOption({
+      name: 'description',
+      schema: z.string().optional(),
+      description: 'Set application description',
+    }),
+    enableZeroDowntime: defineOption({
+      name: 'enable-zero-downtime',
+      schema: z.boolean().default(false),
+      description: 'Enable zero-downtime deployment',
+    }),
+    disableZeroDowntime: defineOption({
+      name: 'disable-zero-downtime',
+      schema: z.boolean().default(false),
+      description: 'Disable zero-downtime deployment',
+    }),
+    enableStickySessions: defineOption({
+      name: 'enable-sticky-sessions',
+      schema: z.boolean().default(false),
+      description: 'Enable sticky sessions',
+    }),
+    disableStickySessions: defineOption({
+      name: 'disable-sticky-sessions',
+      schema: z.boolean().default(false),
+      description: 'Disable sticky sessions',
+    }),
+    enableCancelOnPush: defineOption({
+      name: 'enable-cancel-on-push',
+      schema: z.boolean().default(false),
+      description: 'Enable cancel on push',
+    }),
+    disableCancelOnPush: defineOption({
+      name: 'disable-cancel-on-push',
+      schema: z.boolean().default(false),
+      description: 'Disable cancel on push',
+    }),
+    enableForceHttps: defineOption({
+      name: 'enable-force-https',
+      schema: z.boolean().default(false),
+      description: 'Enable force HTTPS redirection',
+    }),
+    disableForceHttps: defineOption({
+      name: 'disable-force-https',
+      schema: z.boolean().default(false),
+      description: 'Disable force HTTPS redirection',
+    }),
+    enableTask: defineOption({
+      name: 'enable-task',
+      schema: z.boolean().default(false),
+      description: 'Enable application as Clever Task',
+    }),
+    disableTask: defineOption({
+      name: 'disable-task',
+      schema: z.boolean().default(false),
+      description: 'Disable application as Clever Task',
+    }),
+  },
+  async handler(options) {
+    const { alias, appIdOrName, ...rawOptions } = options;
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+    const newOptions = ApplicationConfiguration.parseOptions(rawOptions);
+
+    if (Object.keys(newOptions).length === 0) {
+      throw new Error('No configuration to update');
+    }
+
+    const app = await Application.updateOptions(ownerId, appId, newOptions);
+
+    ApplicationConfiguration.printAllValues(app);
+  },
+});

package/src/commands/console/console.command.js

@@ -0,0 +1,31 @@
+import { defineCommand } from '../../lib/define-command.js';
+import * as AppConfig from '../../models/app_configuration.js';
+import * as Application from '../../models/application.js';
+import { openBrowser } from '../../models/utils.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+
+export const consoleCommand = defineCommand({
+  description: 'Open an application in the Console',
+  since: '1.0.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [],
+  async handler(options) {
+    const { alias, app: appIdOrName } = options;
+
+    const { apps } = await AppConfig.loadApplicationConf();
+    // If no app is linked or asked, open the Console without any context
+    if (apps.length === 0 && !appIdOrName) {
+      await openBrowser('/', 'Opening the Console in your browser');
+      return;
+    }
+
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+    const prefixPath = ownerId.startsWith('user_') ? 'users/me' : `organisations/${ownerId}`;
+    const consolePath = `/${prefixPath}/applications/${appId}`;
+
+    await openBrowser(consolePath, `Opening the Console in your browser for application ${appId}`);
+  },
+});

package/src/commands/console/console.docs.md

@@ -0,0 +1,16 @@
+# 📖 `clever console` command reference
+
+## ➡️ `clever console` <kbd>Since 1.0.0</kbd>
+
+Open an application in the Console
+
+```bash
+clever console [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)|