clever-tools 4.4.0 → 4.5.0

package/src/commands/profile/profile.docs.md

@@ -0,0 +1,23 @@
+# 📖 `clever profile` command reference
+
+## ➡️ `clever profile` <kbd>Since 0.10.1</kbd>
+
+Display the profile of the current user
+
+```bash
+clever profile [options]
+```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-F`, `--format` `<format>`|Output format (human, json) (default: human)|
+
+## ➡️ `clever profile open` <kbd>Since 3.11.0</kbd>
+
+Open your profile in the Console
+
+```bash
+clever profile open
+```

package/src/commands/profile/profile.open.command.js

@@ -0,0 +1,12 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { openBrowser } from '../../models/utils.js';
+
+export const profileOpenCommand = defineCommand({
+  description: 'Open your profile in the Console',
+  since: '3.11.0',
+  options: {},
+  args: [],
+  async handler() {
+    await openBrowser('/users/me/information', 'Opening the profile page in your browser');
+  },
+});

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

@@ -0,0 +1,40 @@
+import { getAllExposedEnvVars } from '@clevercloud/client/esm/api/v2/application.js';
+import { toNameEqualsValueString } from '@clevercloud/client/esm/utils/env-vars.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, envFormatOption } from '../global.options.js';
+
+export const publishedConfigCommand = defineCommand({
+  description: 'Manage the configuration made available to other applications by this application',
+  since: '0.5.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+    format: envFormatOption,
+  },
+  args: [],
+  async handler(options) {
+    const { alias, app: appIdOrName, format } = options;
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+    const publishedConfigs = await getAllExposedEnvVars({ id: ownerId, appId }).then(sendToApi);
+    const pairs = Object.entries(publishedConfigs).map(([name, value]) => ({ name, value }));
+
+    switch (format) {
+      case 'json': {
+        Logger.printJson(pairs);
+        break;
+      }
+      case 'shell':
+        Logger.println(toNameEqualsValueString(pairs, { addExports: true }));
+        break;
+      case 'human':
+      default: {
+        Logger.println('# Published configs');
+        Logger.println(toNameEqualsValueString(pairs, { addExports: false }));
+      }
+    }
+  },
+});

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

@@ -0,0 +1,77 @@
+# 📖 `clever published-config` command reference
+
+## ➡️ `clever published-config` <kbd>Since 0.5.0</kbd>
+
+Manage the configuration made available to other applications by this application
+
+```bash
+clever published-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)|
+|`-F`, `--format` `<format>`|Output format (human, json, shell) (default: human)|
+
+## ➡️ `clever published-config import` <kbd>Since 0.5.0</kbd>
+
+Load published configuration from STDIN
+(WARNING: this deletes all current variables and replace them with the new list loaded from STDIN)
+
+```bash
+clever published-config import [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)|
+|`--json`|Import variables as JSON (an array of { "name": "THE_NAME", "value": "THE_VALUE" } objects)|
+
+## ➡️ `clever published-config rm` <kbd>Since 0.5.0</kbd>
+
+Remove a published configuration variable from an application
+
+```bash
+clever published-config rm <variable-name> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`variable-name`|Name of the environment variable|
+
+### ⚙️ 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 published-config set` <kbd>Since 0.5.0</kbd>
+
+Add or update a published configuration item named <variable-name> with the value <variable-value>
+
+```bash
+clever published-config set <variable-name> <variable-value> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`variable-name`|Name of the environment variable|
+|`variable-value`|Value of the environment variable|
+
+### ⚙️ 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/published-config/published-config.import.command.js

@@ -0,0 +1,29 @@
+import { updateAllExposedEnvVars } 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 * as variables from '../../models/variables.js';
+import { aliasOption, appIdOrNameOption, importAsJsonOption } from '../global.options.js';
+
+export const publishedConfigImportCommand = defineCommand({
+  description:
+    'Load published configuration from STDIN\n(WARNING: this deletes all current variables and replace them with the new list loaded from STDIN)',
+  since: '0.5.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+    json: importAsJsonOption,
+  },
+  args: [],
+  async handler(options) {
+    const { alias, app: appIdOrName, json } = options;
+    const format = json ? 'json' : 'name-equals-value';
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+    const publishedConfigs = await variables.readVariablesFromStdin(format);
+    await updateAllExposedEnvVars({ id: ownerId, appId }, publishedConfigs).then(sendToApi);
+
+    Logger.println('Your published configs have been set');
+  },
+});

package/src/commands/published-config/published-config.rm.command.js

@@ -0,0 +1,27 @@
+import { getAllExposedEnvVars, updateAllExposedEnvVars } 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 { envVariableNameArg } from '../global.args.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+
+export const publishedConfigRmCommand = defineCommand({
+  description: 'Remove a published configuration variable from an application',
+  since: '0.5.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [envVariableNameArg],
+  async handler(options, varName) {
+    const { alias, app: appIdOrName } = options;
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+    const publishedConfigs = await getAllExposedEnvVars({ id: ownerId, appId }).then(sendToApi);
+    delete publishedConfigs[varName];
+    await updateAllExposedEnvVars({ id: ownerId, appId }, publishedConfigs).then(sendToApi);
+
+    Logger.println('Your published config item has been successfully removed');
+  },
+});

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

@@ -0,0 +1,34 @@
+import { getAllExposedEnvVars, updateAllExposedEnvVars } from '@clevercloud/client/esm/api/v2/application.js';
+import { validateName } from '@clevercloud/client/esm/utils/env-vars.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 { envVariableNameArg, envVariableValueArg } from '../global.args.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+
+export const publishedConfigSetCommand = defineCommand({
+  description: 'Add or update a published configuration item named <variable-name> with the value <variable-value>',
+  since: '0.5.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [envVariableNameArg, envVariableValueArg],
+  async handler(options, varName, varValue) {
+    const { alias, app: appIdOrName } = options;
+
+    const nameIsValid = validateName(varName);
+    if (!nameIsValid) {
+      throw new Error(`Published config name ${varName} is invalid`);
+    }
+
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+    const publishedConfigs = await getAllExposedEnvVars({ id: ownerId, appId }).then(sendToApi);
+    publishedConfigs[varName] = varValue;
+    await updateAllExposedEnvVars({ id: ownerId, appId }, publishedConfigs).then(sendToApi);
+
+    Logger.println('Your published config item has been successfully saved');
+  },
+});

package/src/commands/restart/restart.command.js

@@ -0,0 +1,77 @@
+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 Application from '../../models/application.js';
+import * as ExitStrategy from '../../models/exit-strategy-option.js';
+import * as git from '../../models/git.js';
+import * as Log from '../../models/log-v4.js';
+import {
+  aliasOption,
+  appIdOrNameOption,
+  exitOnDeployOption,
+  followDeployLogsOption,
+  quietOption,
+} from '../global.options.js';
+
+export const restartCommand = defineCommand({
+  description: 'Start or restart an application',
+  since: '0.4.0',
+  options: {
+    commit: defineOption({
+      name: 'commit',
+      schema: z.string().optional(),
+      description: 'Restart the application with a specific commit ID',
+      placeholder: 'commit-id',
+    }),
+    withoutCache: defineOption({
+      name: 'without-cache',
+      schema: z.boolean().default(false),
+      description: 'Restart the application without using cache',
+    }),
+    alias: aliasOption,
+    app: appIdOrNameOption,
+    quiet: quietOption,
+    follow: followDeployLogsOption,
+    exitOnDeploy: exitOnDeployOption,
+  },
+  args: [],
+  async handler(options) {
+    const { alias, app: appIdOrName, quiet, commit, withoutCache, follow, exitOnDeploy } = options;
+
+    const exitStrategy = ExitStrategy.get(follow, exitOnDeploy);
+
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+    const fullCommitId = await git.resolveFullCommitId(commit);
+    const app = await Application.get(ownerId, appId);
+
+    if (app == null) {
+      throw new Error("The application doesn't exist");
+    }
+
+    const remoteCommitId = app.commitId;
+
+    const commitId = fullCommitId || remoteCommitId;
+    if (commitId != null) {
+      const cacheSuffix = withoutCache ? ' without using cache' : '';
+      Logger.println(
+        `🔄 Restarting ${styleText('bold', app.name)}${cacheSuffix} ${styleText('grey', `(${commitId})`)}`,
+      );
+    }
+
+    // This should be handled by the API when a deployment ID is set but we'll do this for now
+    const redeployDate = new Date();
+
+    const redeploy = await Application.redeploy(ownerId, appId, fullCommitId, withoutCache);
+
+    return Log.watchDeploymentAndDisplayLogs({
+      ownerId,
+      appId,
+      deploymentId: redeploy.deploymentId,
+      quiet,
+      redeployDate,
+      exitStrategy,
+    });
+  },
+});

package/src/commands/restart/restart.docs.md

@@ -0,0 +1,21 @@
+# 📖 `clever restart` command reference
+
+## ➡️ `clever restart` <kbd>Since 0.4.0</kbd>
+
+Start or restart an application
+
+```bash
+clever restart [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)|
+|`--commit` `<commit-id>`|Restart the application with a specific commit ID|
+|`-e`, `--exit-on` `<step>`|Step at which the logs streaming is ended, steps are: deploy-start, deploy-end, never (default: deploy-end)|
+|`--follow`|Continue to follow logs after deployment has ended *(deprecated, use `--exit-on never` instead)*|
+|`-q`, `--quiet`|Don't show logs during deployment|
+|`--without-cache`|Restart the application without using cache|

package/src/commands/scale/scale.command.js

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+import { defineCommand } from '../../lib/define-command.js';
+import { defineOption } from '../../lib/define-option.js';
+import { Logger } from '../../logger.js';
+import * as Application from '../../models/application.js';
+import { listAvailableFlavors } from '../../models/application.js';
+import { buildFlavor, flavor } from '../../parsers.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+
+function validateOptions(options) {
+  let { flavor, minFlavor, maxFlavor } = options;
+  let { instances, minInstances, maxInstances, buildFlavor } = options;
+
+  if ([flavor, minFlavor, maxFlavor, instances, minInstances, maxInstances, buildFlavor].every((v) => v == null)) {
+    throw new Error('You should provide at least 1 option');
+  }
+
+  if (flavor != null) {
+    if (minFlavor != null || maxFlavor != null) {
+      throw new Error("You can't use --flavor and --min-flavor or --max-flavor at the same time");
+    }
+    minFlavor = flavor;
+    maxFlavor = flavor;
+  }
+
+  if (instances != null) {
+    if (minInstances != null || maxInstances != null) {
+      throw new Error("You can't use --instances and --min-instances or --max-instances at the same time");
+    }
+    minInstances = instances;
+    maxInstances = instances;
+  }
+
+  if (minInstances != null && maxInstances != null && minInstances > maxInstances) {
+    throw new Error("min-instances can't be greater than max-instances");
+  }
+
+  if (minFlavor != null && maxFlavor != null) {
+    const minFlavorIndex = Application.listAvailableFlavors().indexOf(minFlavor);
+    const maxFlavorIndex = Application.listAvailableFlavors().indexOf(maxFlavor);
+    if (minFlavorIndex > maxFlavorIndex) {
+      throw new Error("min-flavor can't be a greater flavor than max-flavor");
+    }
+  }
+
+  return { minFlavor, maxFlavor, minInstances, maxInstances, buildFlavor };
+}
+
+export const scaleCommand = defineCommand({
+  description: 'Change scalability of an application',
+  since: '0.4.0',
+  options: {
+    flavor: defineOption({
+      name: 'flavor',
+      schema: z.string().transform(flavor).optional(),
+      description: 'The instance size of your application',
+      placeholder: 'flavor',
+      complete: listAvailableFlavors,
+    }),
+    minFlavor: defineOption({
+      name: 'min-flavor',
+      schema: z.string().transform(flavor).optional(),
+      description: 'The minimum scale size of your application',
+      placeholder: 'flavor',
+      complete: listAvailableFlavors,
+    }),
+    maxFlavor: defineOption({
+      name: 'max-flavor',
+      schema: z.string().transform(flavor).optional(),
+      description: 'The maximum instance size of your application',
+      placeholder: 'flavor',
+      complete: listAvailableFlavors,
+    }),
+    instances: defineOption({
+      name: 'instances',
+      schema: z.coerce.number().int().min(1).max(20).optional(),
+      description: 'The number of parallel instances',
+      placeholder: 'instances',
+    }),
+    minInstances: defineOption({
+      name: 'min-instances',
+      schema: z.coerce.number().int().min(1).max(20).optional(),
+      description: 'The minimum number of parallel instances',
+      placeholder: 'number',
+    }),
+    maxInstances: defineOption({
+      name: 'max-instances',
+      schema: z.coerce.number().int().min(1).max(20).optional(),
+      description: 'The maximum number of parallel instances',
+      placeholder: 'number',
+    }),
+    buildFlavor: defineOption({
+      name: 'build-flavor',
+      schema: z.string().transform(buildFlavor).optional(),
+      description: "The size of the build instance, or 'disabled' if you want to disable dedicated build instances",
+      placeholder: 'flavor',
+    }),
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [],
+  async handler(options) {
+    const { alias, app: appIdOrName } = options;
+    const { minFlavor, maxFlavor, minInstances, maxInstances, buildFlavor } = validateOptions(options);
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+    await Application.setScalability(
+      appId,
+      ownerId,
+      {
+        minFlavor,
+        maxFlavor,
+        minInstances,
+        maxInstances,
+      },
+      buildFlavor,
+    );
+
+    Logger.println('App rescaled successfully');
+  },
+});

package/src/commands/scale/scale.docs.md

@@ -0,0 +1,23 @@
+# 📖 `clever scale` command reference
+
+## ➡️ `clever scale` <kbd>Since 0.4.0</kbd>
+
+Change scalability of an application
+
+```bash
+clever scale [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)|
+|`--build-flavor` `<flavor>`|The size of the build instance, or 'disabled' if you want to disable dedicated build instances|
+|`--flavor` `<flavor>`|The instance size of your application|
+|`--instances` `<instances>`|The number of parallel instances|
+|`--max-flavor` `<flavor>`|The maximum instance size of your application|
+|`--max-instances` `<number>`|The maximum number of parallel instances|
+|`--min-flavor` `<flavor>`|The minimum scale size of your application|
+|`--min-instances` `<number>`|The minimum number of parallel instances|

package/src/commands/service/service.command.js

@@ -0,0 +1,91 @@
+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 Addon from '../../models/addon.js';
+import * as Application from '../../models/application.js';
+import { aliasOption, appIdOrNameOption, humanJsonOutputFormatOption } from '../global.options.js';
+
+export const serviceCommand = defineCommand({
+  description: 'Manage service dependencies',
+  since: '0.5.0',
+  options: {
+    onlyApps: defineOption({
+      name: 'only-apps',
+      schema: z.boolean().default(false),
+      description: 'Only show app dependencies',
+    }),
+    onlyAddons: defineOption({
+      name: 'only-addons',
+      schema: z.boolean().default(false),
+      description: 'Only show add-on dependencies',
+    }),
+    showAll: defineOption({
+      name: 'show-all',
+      schema: z.boolean().default(false),
+      description: 'Show all available add-ons and applications',
+    }),
+    alias: aliasOption,
+    app: appIdOrNameOption,
+    format: humanJsonOutputFormatOption,
+  },
+  args: [],
+  async handler(options) {
+    const { alias, app: appIdOrName, showAll, onlyApps, onlyAddons, format } = options;
+    if (onlyApps && onlyAddons) {
+      throw new Error('--only-apps and --only-addons are mutually exclusive');
+    }
+
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+    const formattedServices = {};
+
+    if (!onlyAddons) {
+      const apps = await Application.listDependencies(ownerId, appId, showAll);
+      formattedServices.applications = apps.map((app) => ({
+        id: app.id,
+        name: app.name,
+        isLinked: app.isLinked,
+      }));
+    }
+
+    if (!onlyApps) {
+      const addons = await Addon.list(ownerId, appId, showAll);
+      formattedServices.addons = addons.map((addon) => ({
+        id: addon.id,
+        realId: addon.realId,
+        name: addon.name,
+        isLinked: addon.isLinked,
+      }));
+    }
+
+    switch (format) {
+      case 'json': {
+        Logger.printJson(formattedServices);
+        break;
+      }
+      case 'human':
+      default: {
+        const { applications = [], addons = [] } = formattedServices;
+
+        if (applications.length === 0 && addons.length === 0) {
+          Logger.printInfo(
+            `No linked services found, use ${styleText('blue', 'clever service link-app')} or ${styleText('blue', 'clever service link-addon')} to link services to an application`,
+          );
+          return;
+        }
+
+        if (applications.length > 0) {
+          Logger.println('Applications:');
+          applications.forEach(({ isLinked, name }) => Logger.println(`${isLinked ? '*' : ' '} ${name}`));
+        }
+
+        if (addons.length > 0) {
+          Logger.println('Addons:');
+          addons.forEach(({ isLinked, name, realId }) => Logger.println(`${isLinked ? '*' : ' '} ${name} (${realId})`));
+        }
+      }
+    }
+  },
+});