clever-tools 3.14.0 → 4.0.0

package/src/commands/config.js

@@ -1,16 +1,16 @@
+import { styleText } from 'node:util';
+import { Logger } from '../logger.js';
 import * as Application from '../models/application.js';
 import * as ApplicationConfiguration from '../models/application_configuration.js';
-import { Logger } from '../logger.js';
-import colors from 'colors/safe.js';
 
-export async function list (params) {
+export async function list(params) {
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
   const app = await Application.get(ownerId, appId);
   ApplicationConfiguration.printAllValues(app);
 }
 
-export async function get (params) {
+export async function get(params) {
   const [configurationName] = params.args;
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
@@ -18,7 +18,7 @@ export async function get (params) {
   ApplicationConfiguration.printValue(app, configurationName);
 }
 
-export async function set (params) {
+export async function set(params) {
   const [configurationName, configurationValue] = params.args;
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
@@ -27,10 +27,12 @@ export async function set (params) {
     [config.name]: ApplicationConfiguration.parse(config, configurationValue),
   };
   const app = await Application.updateOptions(ownerId, appId, options);
-  Logger.printSuccess(`Config ${colors.green(config.id)} successfully updated to ${colors.green(ApplicationConfiguration.formatValue(config, app[config.name]))}!`);
+  Logger.printSuccess(
+    `Config ${styleText('green', config.id)} successfully updated to ${styleText('green', ApplicationConfiguration.formatValue(config, app[config.name]).toString())}!`,
+  );
 }
 
-export async function update (params) {
+export async function update(params) {
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
   const options = ApplicationConfiguration.parseOptions(params.options);

package/src/commands/console.js

@@ -1,8 +1,8 @@
-import * as Application from '../models/application.js';
 import * as AppConfig from '../models/app_configuration.js';
+import * as Application from '../models/application.js';
 import { openBrowser } from '../models/utils.js';
 
-export async function openConsole (params) {
+export async function openConsole(params) {
   const { alias, app: appIdOrName } = params.options;
 
   const { apps } = await AppConfig.loadApplicationConf();
@@ -13,7 +13,7 @@ export async function openConsole (params) {
   }
 
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-  const prefixPath = (ownerId.startsWith('user_')) ? 'users/me' : `organisations/${ownerId}`;
+  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/create.js

@@ -1,24 +1,22 @@
 import path from 'node:path';
-import colors from 'colors/safe.js';
-import * as Application from '../models/application.js';
-import * as AppConfig from '../models/app_configuration.js';
+import { styleText } from 'node:util';
 import { Logger } from '../logger.js';
-import { isGitWorkingDirectoryClean, isInsideGitRepo } from '../models/git.js';
+import * as AppConfig from '../models/app_configuration.js';
+import * as Application from '../models/application.js';
 import { conf } from '../models/configuration.js';
+import { isGitWorkingDirectoryClean, isInsideGitRepo } from '../models/git.js';
 
-export async function create (params) {
+export async function create(params) {
   const { type: typeName } = params.options;
   const [rawName] = params.args;
   const { org: orgaIdOrName, alias, region, github: githubOwnerRepo, format, task: taskCommand } = params.options;
   const { apps } = await AppConfig.loadApplicationConf();
 
   // Application name is optionnal, use current directory name if not specified (empty string)
-  const name = (rawName !== '') ? rawName : getCurrentDirectoryName();
+  const name = rawName !== '' ? rawName : getCurrentDirectoryName();
 
-  const isTask = (taskCommand != null);
-  const envVars = isTask
-    ? { CC_RUN_COMMAND: taskCommand }
-    : {};
+  const isTask = taskCommand != null;
+  const envVars = isTask ? { CC_RUN_COMMAND: taskCommand } : {};
 
   AppConfig.checkAlreadyLinked(apps, name, alias);
 
@@ -42,16 +40,16 @@ export async function create (params) {
     default:
       await displayAppCreation(app, alias, github, taskCommand);
   }
-};
+}
 
-function getGithubDetails (githubOwnerRepo) {
+function getGithubDetails(githubOwnerRepo) {
   if (githubOwnerRepo != null) {
     const [owner, name] = githubOwnerRepo.split('/');
     return { owner, name };
   }
 }
 
-function getCurrentDirectoryName () {
+function getCurrentDirectoryName() {
   return path.basename(process.cwd());
 }
 
@@ -62,16 +60,15 @@ function getCurrentDirectoryName () {
  * @param {Object} github - The GitHub details
  * @param {string} taskCommand - The task command
  */
-async function displayAppCreation (app, alias, github, taskCommand) {
-
-  Logger.printSuccess(`Application ${colors.green(app.name)} successfully created!`);
+async function displayAppCreation(app, alias, github, taskCommand) {
+  Logger.printSuccess(`Application ${styleText('green', app.name)} successfully created!`);
 
   const hasDistinctAlias = alias != null && alias !== app.name;
   const isTask = app.instance.lifetime === 'TASK';
 
   Logger.println();
   printFieldsAsTable(2, {
-    Type: colors.blue(`⬢ ${app.instance.variant.name}`),
+    Type: styleText('blue', `⬢ ${app.instance.variant.name}`),
     ID: app.id,
     'Organisation ID': app.ownerId,
     Name: app.name,
@@ -82,21 +79,20 @@ async function displayAppCreation (app, alias, github, taskCommand) {
   });
 
   Logger.println();
-  Logger.println('  ' + colors.bold('Next steps:'));
+  Logger.println('  ' + styleText('bold', 'Next steps:'));
 
   if (!github) {
     const isInsideGit = await isInsideGitRepo();
     if (!isInsideGit) {
-      Logger.println(`  ${colors.yellow('!')} Initialize a git repository first, for example:`);
+      Logger.println(`  ${styleText('yellow', '!')} Initialize a git repository first, for example:`);
       Logger.println(`    ${shellCommand('git init')}`);
       Logger.println(`    ${shellCommand('git add .')}`);
       Logger.println(`    ${shellCommand('git commit -m "Initial commit"')}`);
       Logger.println();
-    }
-    else {
+    } else {
       const isClean = await isGitWorkingDirectoryClean();
       if (!isClean) {
-        Logger.println(`  ${colors.yellow('!')} Commit your changes first:`);
+        Logger.println(`  ${styleText('yellow', '!')} Commit your changes first:`);
         Logger.println(`    ${shellCommand('git add .')}`);
         Logger.println(`    ${shellCommand('git commit -m "My changes"')}`);
         Logger.println();
@@ -105,24 +101,29 @@ async function displayAppCreation (app, alias, github, taskCommand) {
   }
 
   if (github) {
-    Logger.println(`  ${colors.blue('→')} Push changes to ${colors.blue(`${github.owner}/${github.name}`)} GitHub repository to trigger a deployment, or ${colors.blue('clever restart')} the latest pushed commit`);
-  }
-  else {
-    Logger.println(`  ${colors.blue('→')} Run ${colors.blue('clever deploy')} ${isTask ? 'to execute your task' : 'to deploy your application'}`);
+    Logger.println(
+      `  ${styleText('blue', '→')} Push changes to ${styleText('blue', `${github.owner}/${github.name}`)} GitHub repository to trigger a deployment, or ${styleText('blue', 'clever restart')} the latest pushed commit`,
+    );
+  } else {
+    Logger.println(
+      `  ${styleText('blue', '→')} Run ${styleText('blue', 'clever deploy')} ${isTask ? 'to execute your task' : 'to deploy your application'}`,
+    );
   }
 
-  Logger.println(`  ${colors.blue('→')} Manage your application at: ${colors.underline(`${conf.GOTO_URL}/${app.id}`)}`);
+  Logger.println(
+    `  ${styleText('blue', '→')} Manage your application at: ${styleText('underline', `${conf.GOTO_URL}/${app.id}`)}`,
+  );
   Logger.println('');
 }
 
-function shellCommand (command) {
-  return `${colors.grey('$')} ${colors.yellow(command)}`;
+function shellCommand(command) {
+  return `${styleText('grey', '$')} ${styleText('yellow', command)}`;
 }
 
-function printFieldsAsTable (indent, fields) {
+function printFieldsAsTable(indent, fields) {
   const fieldsWithValues = Object.fromEntries(Object.entries(fields).filter(([_, value]) => typeof value === 'string'));
   const labelMaxWidth = Math.max(...Object.keys(fieldsWithValues).map((label) => label.length));
   return Object.entries(fieldsWithValues).forEach(([label, value]) => {
-    Logger.println(`${' '.repeat(indent)}${label.padEnd(labelMaxWidth, ' ')}  ${colors.grey(value)}`);
+    Logger.println(`${' '.repeat(indent)}${label.padEnd(labelMaxWidth, ' ')}  ${styleText('grey', value)}`);
   });
 }

package/src/commands/curl.js

@@ -1,12 +1,11 @@
-import { spawn } from 'node:child_process';
-import { conf, loadOAuthConf } from '../models/configuration.js';
 import { addOauthHeader } from '@clevercloud/client/esm/oauth.js';
-import { Logger } from '../logger.js';
-import colors from 'colors/safe.js';
-import curlconverter from 'curlconverter';
 import dedent from 'dedent';
+import { spawn } from 'node:child_process';
+import { styleText } from 'node:util';
+import { Logger } from '../logger.js';
+import { conf, loadOAuthConf } from '../models/configuration.js';
 
-async function loadTokens () {
+async function loadTokens() {
   const tokens = await loadOAuthConf();
   return {
     OAUTH_CONSUMER_KEY: conf.OAUTH_CONSUMER_KEY,
@@ -16,7 +15,7 @@ async function loadTokens () {
   };
 }
 
-function printCleverCurlHelp () {
+function printCleverCurlHelp() {
   Logger.println(dedent`
     Usage: clever curl
     Query Clever Cloud's API using Clever Tools credentials. For example:
@@ -34,8 +33,7 @@ function printCleverCurlHelp () {
   `);
 }
 
-export async function curl () {
-
+export async function curl() {
   // We remove the first three args: "node", "clever" and "curl"
   const curlArgs = process.argv.slice(3);
   const hasNoArgs = curlArgs.length === 0;
@@ -47,47 +45,27 @@ export async function curl () {
     return;
   }
 
-  // WARNING: Version 3.x of curlconverter uses a fork of yargs.
-  // For "reasons", when the command has a help param, it stops the parsing and triggers a very short and localized version of some help (WAT?).
-  // That's why we remove the help param before parsing and "reinstate" it before execution.
-  const curlArgsNoHelp = curlArgs.filter((arg) => arg !== '--help' && arg !== '-h');
-  const curlCommand = ['curl', ...curlArgsNoHelp].join(' ');
-  const requestParams = await parseCurlCommand(curlCommand);
+  const curlUrl = curlArgs.find((part) => part.startsWith(conf.API_HOST));
 
   // We only allow request to the respective API_HOST
-  if (!requestParams.url.startsWith(conf.API_HOST)) {
-    Logger.error('"clever curl" command must be used with ' + colors.blue(conf.API_HOST));
+  if (curlUrl == null) {
+    Logger.error('"clever curl" command must be used with ' + styleText('blue', conf.API_HOST));
     process.exit(1);
   }
 
   const lastCurlArg = curlArgs.at(-1);
   const lastCurlArgIsHelp = lastCurlArg !== '--help' && lastCurlArg !== '-h';
 
-  // Add oAuth header, only if last cURL arg is not help
+  // Add OAuth header, only if last cURL arg is not help
   // We do this because cURL's help arg expect a category
   if (lastCurlArgIsHelp) {
-
     const tokens = await loadTokens();
-    const oauthHeader = await Promise.resolve(requestParams)
+    const oauthHeader = await Promise.resolve({})
       .then(addOauthHeader(tokens))
-      .then((request) => request.headers.Authorization);
+      .then((request) => request.headers.authorization);
 
-    curlArgs.push('-H', `Authorization: ${oauthHeader}`);
+    curlArgs.push('-H', `authorization: ${oauthHeader}`);
   }
 
   spawn('curl', curlArgs, { stdio: 'inherit' });
-
-}
-
-async function parseCurlCommand (curlCommand) {
-
-  const jsonString = curlconverter.toJsonString(curlCommand);
-  const curlRequestParams = JSON.parse(jsonString);
-
-  return {
-    method: curlRequestParams.method,
-    url: curlRequestParams.url,
-    headers: curlRequestParams.headers,
-    queryParams: curlRequestParams.queries,
-  };
 }

package/src/commands/database.js

@@ -1,16 +1,13 @@
-import { sendToApi } from '../models/send-to-api.js';
 import { getBackups } from '@clevercloud/client/esm/api/v2/backups.js';
-import { Logger } from '../logger.js';
-import { formatTable as initFormatTable } from '../format-table.js';
 import fs from 'node:fs';
 import { Writable } from 'node:stream';
+import { formatTable } from '../format-table.js';
+import { Logger } from '../logger.js';
 import { findOwnerId } from '../models/addon.js';
-import { resolveRealId, resolveAddonId } from '../models/ids-resolver.js';
-
-const formatTable = initFormatTable();
-
-export async function listBackups (params) {
+import { resolveAddonId, resolveRealId } from '../models/ids-resolver.js';
+import { sendToApi } from '../models/send-to-api.js';
 
+export async function listBackups(params) {
   const { org, format } = params.options;
   const [addonIdOrRealId] = params.args;
 
@@ -44,29 +41,16 @@ export async function listBackups (params) {
       break;
     }
     case 'human': {
-      const formattedLines = sortedBackups
-        .map((backup) => [
-          backup.backup_id,
-          backup.creation_date,
-          backup.status,
-        ]);
+      const formattedLines = sortedBackups.map((backup) => [backup.backup_id, backup.creation_date, backup.status]);
 
-      const head = [
-        'BACKUP ID',
-        'CREATION DATE',
-        'STATUS',
-      ];
+      const head = ['BACKUP ID', 'CREATION DATE', 'STATUS'];
 
-      Logger.println(formatTable([
-        head,
-        ...formattedLines,
-      ]));
+      Logger.println(formatTable([head, ...formattedLines]));
     }
   }
 }
 
-export async function downloadBackups (params) {
-
+export async function downloadBackups(params) {
   const { org, output } = params.options;
   const [addonIdOrRealId, backupId] = params.args;
 
@@ -85,9 +69,5 @@ export async function downloadBackups (params) {
     throw new Error('Failed to download backup');
   }
 
-  await response
-    .body
-    .pipeTo(
-      Writable.toWeb(output ? fs.createWriteStream(output) : process.stdout),
-    );
+  await response.body.pipeTo(Writable.toWeb(output ? fs.createWriteStream(output) : process.stdout));
 }

package/src/commands/delete.js

@@ -1,24 +1,24 @@
+import { styleText } from 'node:util';
+import { Logger } from '../logger.js';
 import * as AppConfig from '../models/app_configuration.js';
 import * as Application from '../models/application.js';
-import { Logger } from '../logger.js';
-import colors from 'colors/safe.js';
 
-export async function deleteApp (params) {
+export async function deleteApp(params) {
   const { alias, app: appIdOrName, yes: skipConfirmation } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   const app = await Application.get(ownerId, appId);
   if (app == null) {
-    throw new Error('The application doesn\'t exist');
+    throw new Error("The application doesn't exist");
   }
 
   // delete app
   await Application.deleteApp(app, skipConfirmation);
-  Logger.printSuccess(`Application ${colors.green(colors.bold(`${app.name}`))} successfully deleted!`);
-  Logger.println(`  ${colors.grey('•')} Application ID: ${colors.grey(app.id)}`);
+  Logger.printSuccess(`Application ${styleText('green', styleText('bold', `${app.name}`))} successfully deleted!`);
+  Logger.println(`  ${styleText('grey', '•')} Application ID: ${styleText('grey', app.id)}`);
 
   const wasUnlinked = await AppConfig.removeLinkedApplication({ appId, alias });
   if (wasUnlinked) {
-    Logger.println(`  ${colors.blue('→')} Local alias ${colors.blue(alias || app.name)} unlinked`);
+    Logger.println(`  ${styleText('blue', '→')} Local alias ${styleText('blue', alias || app.name)} unlinked`);
   }
-};
+}

package/src/commands/deploy.js

@@ -1,19 +1,27 @@
-import colors from 'colors/safe.js';
+import { getAllDeployments } from '@clevercloud/client/esm/api/v2/application.js';
 import dedent from 'dedent';
-
+import { styleText } from 'node:util';
+import { Logger } from '../logger.js';
 import * as AppConfig from '../models/app_configuration.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 { Logger } from '../logger.js';
-import { getAllDeployments } from '@clevercloud/client/esm/api/v2/application.js';
 import { sendToApi } from '../models/send-to-api.js';
-import * as ExitStrategy from '../models/exit-strategy-option.js';
 
 // Once the API call to redeploy() has been triggered successfully,
 // the rest (waiting for deployment state to evolve and displaying logs) is done with auto retry (resilient to network failures)
-export async function deploy (params) {
-  const { alias, branch: branchName, tag: tagName, quiet, force, follow, 'same-commit-policy': sameCommitPolicy, 'exit-on': exitOnDeploy } = params.options;
+export async function deploy(params) {
+  const {
+    alias,
+    branch: branchName,
+    tag: tagName,
+    quiet,
+    force,
+    follow,
+    'same-commit-policy': sameCommitPolicy,
+    'exit-on': exitOnDeploy,
+  } = params.options;
 
   const exitStrategy = ExitStrategy.get(follow, exitOnDeploy);
 
@@ -23,15 +31,14 @@ export async function deploy (params) {
   const branchRefspec = await getBranchToDeploy(branchName, tagName);
   const commitIdToPush = await git.getBranchCommit(branchRefspec);
   const remoteHeadCommitId = await git.getRemoteCommit(appData.deployUrl);
-  const deployedCommitId = await Application.get(ownerId, appId)
-    .then(({ commitId }) => commitId);
+  const deployedCommitId = await Application.get(ownerId, appId).then(({ commitId }) => commitId);
 
   await git.addRemote(appData.alias, appData.deployUrl);
 
   if (commitIdToPush === remoteHeadCommitId) {
     switch (sameCommitPolicy) {
       case 'ignore':
-        Logger.printSuccess(`The application is up-to-date (${colors.grey(remoteHeadCommitId)})`);
+        Logger.printSuccess(`The application is up-to-date (${styleText('grey', remoteHeadCommitId)})`);
         return;
       case 'restart':
         return restartOnSameCommit(ownerId, appId, commitIdToPush, quiet, false, exitStrategy);
@@ -39,10 +46,11 @@ export async function deploy (params) {
         return restartOnSameCommit(ownerId, appId, commitIdToPush, quiet, true, exitStrategy);
       case 'error':
       default: {
-        const restartCommand = commitIdToPush !== deployedCommitId ? `clever restart --commit ${commitIdToPush}` : 'clever restart';
+        const restartCommand =
+          commitIdToPush !== deployedCommitId ? `clever restart --commit ${commitIdToPush}` : 'clever restart';
         throw new Error(dedent`
-          Remote HEAD has the same commit as the one to push ${colors.grey(`(${remoteHeadCommitId})`)}, your application is up-to-date.
-          Create a new commit, use ${colors.blue(restartCommand)} or the ${colors.blue('--same-commit-policy')} option.
+          Remote HEAD has the same commit as the one to push ${styleText('grey', `(${remoteHeadCommitId})`)}, your application is up-to-date.
+          Create a new commit, use ${styleText('blue', restartCommand)} or the ${styleText('blue', '--same-commit-policy')} option.
         `);
       }
     }
@@ -54,66 +62,72 @@ export async function deploy (params) {
   const knownDeployments = await getAllDeployments({ id: ownerId, appId, limit: 5 }).then(sendToApi);
 
   Logger.println(dedent`
-    ${colors.bold(`🚀 Deploying ${colors.green(appData.name)}`)}
-       Application ID  ${colors.grey(`${appId}`)}
-       Organisation ID ${colors.grey(`${ownerId}`)}
+    ${styleText('bold', `🚀 Deploying ${styleText('green', appData.name)}`)}
+       Application ID  ${styleText('grey', `${appId}`)}
+       Organisation ID ${styleText('grey', `${ownerId}`)}
   `);
 
   Logger.println();
 
-  Logger.println(colors.bold('🔀 Git information'));
+  Logger.println(styleText('bold', '🔀 Git information'));
   if (remoteHeadCommitId == null || deployedCommitId == null) {
-    Logger.println(`   ${colors.yellow('!')} App is brand new, no commits on remote yet`);
-  }
-  else {
-    Logger.println(`   Remote head     ${colors.yellow(remoteHeadCommitId)} (${branchRefspec})`);
-    Logger.println(`   Deployed commit ${colors.yellow(deployedCommitId)}`);
+    Logger.println(`   ${styleText('yellow', '!')} App is brand new, no commits on remote yet`);
+  } else {
+    Logger.println(`   Remote head     ${styleText('yellow', remoteHeadCommitId)} (${branchRefspec})`);
+    Logger.println(`   Deployed commit ${styleText('yellow', deployedCommitId)}`);
   }
-  Logger.println(`   Local commit    ${colors.yellow(commitIdToPush)} ${colors.blue('[will be deployed]')}`);
+  Logger.println(
+    `   Local commit    ${styleText('yellow', commitIdToPush)} ${styleText('blue', '[will be deployed]')}`,
+  );
 
   Logger.println();
 
   Logger.println(dedent`
-    ${colors.bold('🔄 Deployment progress')}
-       ${colors.blue('→ Pushing source code to Clever Cloud…')}
+    ${styleText('bold', '🔄 Deployment progress')}
+       ${styleText('blue', '→ Pushing source code to Clever Cloud…')}
   `);
 
-  await git.push(appData.deployUrl, commitIdToPush, force)
-    .catch(async (e) => {
-      const isShallow = await git.isShallow();
-      if (isShallow) {
-        throw new Error('Failed to push your source code because your repository is shallow and therefore cannot be pushed to the Clever Cloud remote.');
-      }
-      else {
-        throw e;
-      }
-    });
-
-  await Logger.println(`   ${colors.green('✓ Code pushed to Clever Cloud')}`);
-
-  return Log.watchDeploymentAndDisplayLogs({ ownerId, appId, commitId: commitIdToPush, knownDeployments, quiet, exitStrategy });
+  await git.push(appData.deployUrl, commitIdToPush, force).catch(async (e) => {
+    const isShallow = await git.isShallow();
+    if (isShallow) {
+      throw new Error(
+        'Failed to push your source code because your repository is shallow and therefore cannot be pushed to the Clever Cloud remote.',
+      );
+    } else {
+      throw e;
+    }
+  });
+
+  await Logger.println(`   ${styleText('green', '✓ Code pushed to Clever Cloud')}`);
+
+  return Log.watchDeploymentAndDisplayLogs({
+    ownerId,
+    appId,
+    commitId: commitIdToPush,
+    knownDeployments,
+    quiet,
+    exitStrategy,
+  });
 }
 
-async function restartOnSameCommit (ownerId, appId, commitIdToPush, quiet, withoutCache, exitStrategy) {
+async function restartOnSameCommit(ownerId, appId, commitIdToPush, quiet, withoutCache, exitStrategy) {
   const cacheSuffix = withoutCache ? ' without using cache' : '';
-  Logger.println(`🔄 Restarting ${colors.bold(appId)}${cacheSuffix} ${colors.grey(`(${commitIdToPush})`)}`);
+  Logger.println(`🔄 Restarting ${styleText('bold', appId)}${cacheSuffix} ${styleText('grey', `(${commitIdToPush})`)}`);
 
   const restart = await Application.redeploy(ownerId, appId, commitIdToPush, withoutCache);
   return Log.watchDeploymentAndDisplayLogs({ ownerId, appId, deploymentId: restart.deploymentId, quiet, exitStrategy });
 }
 
-async function getBranchToDeploy (branchName, tagName) {
+async function getBranchToDeploy(branchName, tagName) {
   if (tagName) {
     const useTag = await git.isExistingTag(tagName);
     if (useTag) {
       const tagRefspec = await git.getFullBranch(tagName);
       return tagRefspec;
-    }
-    else {
+    } else {
       throw new Error(`Tag ${tagName} doesn't exist locally`);
     }
-  }
-  else {
+  } else {
     return await git.getFullBranch(branchName);
   }
 }