clever-tools 3.14.0 → 4.0.0

package/src/models/deployments.js

@@ -1,20 +1,16 @@
-import { promisify } from 'node:util';
+import { getAllDeployments, getDeployment } from '@clevercloud/client/esm/api/v2/application.js';
+import { setTimeout as delay } from 'node:timers/promises';
 import { Logger } from '../logger.js';
-import { getDeployment, getAllDeployments } from '@clevercloud/client/esm/api/v2/application.js';
 import { sendToApi } from './send-to-api.js';
 
-const delay = promisify(setTimeout);
-
 const DEPLOYMENT_POLLING_DELAY = 5000;
 const BACKOFF_FACTOR = 1.25;
 const INIT_RETRY_TIMEOUT = 1500;
 const MAX_RETRY_COUNT = 5;
 
-export async function waitForDeploymentStart ({ ownerId, appId, deploymentId, commitId, knownDeployments }) {
-
+export async function waitForDeploymentStart({ ownerId, appId, deploymentId, commitId, knownDeployments }) {
   return waitFor(async () => {
     try {
-
       // In a deploy situation, we don't have the deployment ID so we get the latest deployments,
       // then we match by commit ID and we filter out "known deployments" that existed before the deploy.
       // In a restart situation, we have a deployment ID but fetching it too soon may result in an error so we get latest deployments,
@@ -35,15 +31,14 @@ export async function waitForDeploymentStart ({ ownerId, appId, deploymentId, co
         return deployment;
       }
       Logger.debug('Deployment cannot be found yet');
-    }
-    catch (e) {
+    } catch (e) {
       Logger.debug('Failed to retrieve deployment');
       throw e;
     }
   });
 }
 
-export async function waitForDeploymentEnd ({ ownerId, appId, deploymentId }) {
+export async function waitForDeploymentEnd({ ownerId, appId, deploymentId }) {
   return waitFor(async () => {
     try {
       const deployment = await getDeployment({ id: ownerId, appId, deploymentId }).then(sendToApi);
@@ -53,8 +48,7 @@ export async function waitForDeploymentEnd ({ ownerId, appId, deploymentId }) {
         return deployment;
       }
       Logger.debug(`Deployment is not finished yet (state:${deployment.state})`);
-    }
-    catch (e) {
+    } catch (e) {
       Logger.debug('Failed to retrieve current deployment status');
       throw e;
     }
@@ -65,14 +59,11 @@ export async function waitForDeploymentEnd ({ ownerId, appId, deploymentId }) {
 // Return fetchResult's result if it's not null
 // Retry with simple "infinite polling" if fetchResult succeeds and returns null
 // Retry with exponential backoff if fetchResult fails
-async function waitFor (fetchResult) {
-
+async function waitFor(fetchResult) {
   let failCount = 0;
 
   while (true) {
-
     try {
-
       const result = await fetchResult();
       if (result != null) {
         return result;
@@ -83,8 +74,7 @@ async function waitFor (fetchResult) {
 
       // Retry with simple polling when API calls succeed
       await delay(DEPLOYMENT_POLLING_DELAY);
-    }
-    catch (e) {
+    } catch (e) {
       // If only retry if it's a network error
       if (e.code !== 'EAI_AGAIN') {
         throw e;
@@ -97,7 +87,7 @@ async function waitFor (fetchResult) {
       }
 
       // If API call fails, retry with an exponential backoff
-      await delay(INIT_RETRY_TIMEOUT * (BACKOFF_FACTOR ** failCount));
+      await delay(INIT_RETRY_TIMEOUT * BACKOFF_FACTOR ** failCount);
     }
   }
 }

package/src/models/domain.js

@@ -1,14 +1,13 @@
+import { getAllDomains, getFavouriteDomain } from '@clevercloud/client/esm/api/v2/application.js';
 import _ from 'lodash';
-
 import { Logger } from '../logger.js';
-import { getAllDomains, getFavouriteDomain } from '@clevercloud/client/esm/api/v2/application.js';
-import { sendToApi } from '../models/send-to-api.js';
+import { sendToApi } from './send-to-api.js';
 
-export async function getBest (appId, orgaId) {
+export async function getBest(appId, orgaId) {
   Logger.debug('Trying to get the favourite vhost for ' + appId);
-  return getFavouriteDomain({ id: orgaId, appId }).then(sendToApi)
+  return getFavouriteDomain({ id: orgaId, appId })
+    .then(sendToApi)
     .catch(async (e) => {
-
       if (e.response.status !== 404) {
         throw e;
       }
@@ -18,19 +17,21 @@ export async function getBest (appId, orgaId) {
       const result = selectBest(allDomains);
 
       if (result == null) {
-        throw new Error('Couldn\'t find a domain name');
+        throw new Error("Couldn't find a domain name");
       }
 
       return result;
     });
 }
 
-export function selectBest (vhosts) {
+export function selectBest(vhosts) {
   const customVhost = _.find(vhosts, (vhost) => {
     return !vhost.fqdn.endsWith('.cleverapps.io');
   });
   const withoutDefaultDomain = _.find(vhosts, (vhost) => {
-    return !vhost.fqdn.match(/^app-[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.cleverapps\.io$/);
+    return !vhost.fqdn.match(
+      /^app-[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.cleverapps\.io$/,
+    );
   });
   return customVhost || withoutDefaultDomain || vhosts[0];
 }

package/src/models/drain.js

@@ -9,10 +9,11 @@ const DRAIN_TYPES = [
   { id: 'NewRelicHTTP', apiKey: 'MANDATORY' },
 ];
 
-export function createDrainBody (appId, drainTargetURL, drainTargetType, drainTargetCredentials, drainTargetConfig) {
-
+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.");
+    throw new Error(
+      "Credentials are: optional for HTTP, mandatory for ElasticSearch, NewRelicHTTP and TCPSyslog/UDPSyslog don't need them.",
+    );
   }
 
   const body = {
@@ -37,7 +38,7 @@ export function createDrainBody (appId, drainTargetURL, drainTargetType, drainTa
   return body;
 }
 
-export function authorizeDrainCreation (drainTargetType, drainTargetCredentials, drainTargetConfig) {
+export function authorizeDrainCreation(drainTargetType, drainTargetCredentials, drainTargetConfig) {
   if (drainTypeExists(drainTargetType)) {
     // retrieve field for drain type ('mandatory', 'optional', undefined)
     const credStatus = fieldStatus(drainTargetType).credentials;
@@ -87,46 +88,46 @@ export function authorizeDrainCreation (drainTargetType, drainTargetCredentials,
   }
 }
 
-function fieldStatus (drainTargetType) {
+function fieldStatus(drainTargetType) {
   return DRAIN_TYPES.find(({ id }) => id === drainTargetType);
 }
 
-function drainTypeExists (drainTargetType) {
+function drainTypeExists(drainTargetType) {
   return DRAIN_TYPES.some(({ id }) => id === drainTargetType);
 }
 
-function credentialsExist ({ username, password }) {
+function credentialsExist({ username, password }) {
   return username != null && password != null;
 }
 
-function credentialsEmpty ({ username, password }) {
+function credentialsEmpty({ username, password }) {
   return username == null && password == null;
 }
 
-function indexPrefixExist ({ indexPrefix }) {
+function indexPrefixExist({ indexPrefix }) {
   return indexPrefix != null;
 }
 
-function indexPrefixEmpty ({ indexPrefix }) {
+function indexPrefixEmpty({ indexPrefix }) {
   return indexPrefix == null;
 }
 
-function structuredDataParametersExist ({ structuredDataParameters }) {
+function structuredDataParametersExist({ structuredDataParameters }) {
   return structuredDataParameters != null;
 }
 
-function structuredDataParametersEmpty ({ structuredDataParameters }) {
+function structuredDataParametersEmpty({ structuredDataParameters }) {
   return structuredDataParameters == null;
 }
 
-function keyExist ({ apiKey }) {
+function keyExist({ apiKey }) {
   return apiKey != null;
 }
 
-function keyEmpty ({ apiKey }) {
+function keyEmpty({ apiKey }) {
   return apiKey == null;
 }
 
-export function listDrainTypes () {
+export function listDrainTypes() {
   return cliparse.autocomplete.words(DRAIN_TYPES.map((type) => type.id));
 }

package/src/models/exit-strategy-option.js

@@ -1,20 +1,30 @@
-import colors from 'colors/safe.js';
+import { styleText } from 'node:util';
 import { Logger } from '../logger.js';
 
-export function get (follow, exitOnDeploy) {
+export function get(follow, exitOnDeploy) {
   if (follow) {
     if (exitOnDeploy === 'deploy-start') {
       throw new Error('The `follow` and `exit-on` set to "deploy-start" options are not compatible');
     }
-    Logger.println(colors.yellow('The `follow` option is deprecated and will be removed in an upcoming major, use --exit-on set to "never" instead'));
+    Logger.println(
+      styleText(
+        'yellow',
+        'The `follow` option is deprecated and will be removed in an upcoming major, use --exit-on set to "never" instead',
+      ),
+    );
     return 'never';
   }
   return exitOnDeploy;
 }
 
 // plotQuietWarning: If in quiet mode and exitStrategy set to never plot a warning to indicate that the command will end
-export function plotQuietWarning (exitStrategy, quiet) {
+export function plotQuietWarning(exitStrategy, quiet) {
   if (exitStrategy === 'never' && quiet) {
-    Logger.println(colors.bold.yellow('The "never" exit-on strategy is not compatible with the "quiet" mode, it will exit once the deployment ends'));
+    Logger.println(
+      styleText(
+        ['bold', 'yellow'],
+        'The "never" exit-on strategy is not compatible with the "quiet" mode, it will exit once the deployment ends',
+      ),
+    );
   }
 }

package/src/models/fs-utils.js

@@ -1,9 +1,10 @@
-import { join } from 'node:path';
 import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
 
-export function findPath (dir, name) {
+export function findPath(dir, name) {
   const fullPath = join(dir, name);
-  return fs.stat(fullPath)
+  return fs
+    .stat(fullPath)
     .then(() => dir)
     .catch((e) => {
       if (e.code === 'ENOENT' && dir !== '/') {

package/src/models/git.js

@@ -1,25 +1,23 @@
+import cliparse from 'cliparse';
+import * as git from 'isomorphic-git';
+import _ from 'lodash';
 import fs from 'node:fs';
 import path from 'node:path';
-
-import _ from 'lodash';
-import git from 'isomorphic-git';
-import * as http from './isomorphic-http-with-agent.js';
-import cliparse from 'cliparse';
 import { slugify } from '../lib/slugify.js';
-import { findPath } from './fs-utils.js';
 import { loadOAuthConf } from './configuration.js';
+import { findPath } from './fs-utils.js';
+import * as http from './isomorphic-http-with-agent.js';
 
-async function getRepo () {
+async function getRepo() {
   try {
     const dir = await findPath('.', '.git');
     return { fs, dir, http };
-  }
-  catch (e) {
+  } catch {
     throw new Error('Could not find the .git folder.');
   }
 }
 
-async function onAuth () {
+async function onAuth() {
   const tokens = await loadOAuthConf();
   return {
     username: tokens.token,
@@ -27,7 +25,7 @@ async function onAuth () {
   };
 }
 
-export async function addRemote (remoteName, url) {
+export async function addRemote(remoteName, url) {
   const repo = await getRepo();
   const safeRemoteName = slugify(remoteName);
   const allRemotes = await git.listRemotes({ ...repo });
@@ -38,15 +36,14 @@ export async function addRemote (remoteName, url) {
   }
 }
 
-export async function resolveFullCommitId (commitId) {
+export async function resolveFullCommitId(commitId) {
   if (commitId == null) {
     return null;
   }
   try {
     const repo = await getRepo();
     return await git.expandOid({ ...repo, oid: commitId });
-  }
-  catch (e) {
+  } catch (e) {
     if (e.code === 'ShortOidNotFound') {
       throw new Error(`Commit id ${commitId} is ambiguous`);
     }
@@ -54,7 +51,7 @@ export async function resolveFullCommitId (commitId) {
   }
 }
 
-export async function getRemoteCommit (remoteUrl) {
+export async function getRemoteCommit(remoteUrl) {
   const repo = await getRepo();
   const remoteInfos = await git.getRemoteInfo({
     ...repo,
@@ -64,16 +61,16 @@ export async function getRemoteCommit (remoteUrl) {
   return _.get(remoteInfos, 'refs.heads.master');
 }
 
-export async function getFullBranch (branchName) {
+export async function getFullBranch(branchName) {
   const repo = await getRepo();
   if (branchName === '') {
     const currentBranch = await git.currentBranch({ ...repo, fullname: true });
     return currentBranch || 'HEAD';
   }
   return git.expandRef({ ...repo, ref: branchName });
-};
+}
 
-export async function getBranchCommit (refspec) {
+export async function getBranchCommit(refspec) {
   const repo = await getRepo();
   const oid = await git.resolveRef({ ...repo, ref: refspec });
   // When a refspec refers to an annotated tag, the OID ref represents the annotation and not the commit directly,
@@ -82,7 +79,7 @@ export async function getBranchCommit (refspec) {
   return res.oid;
 }
 
-export async function isExistingTag (tag) {
+export async function isExistingTag(tag) {
   const repo = await getRepo();
   const tags = await git.listTags({
     ...repo,
@@ -90,7 +87,7 @@ export async function isExistingTag (tag) {
   return tags.includes(tag);
 }
 
-export async function push (remoteUrl, branchRefspec, force) {
+export async function push(remoteUrl, branchRefspec, force) {
   const repo = await getRepo();
   try {
     const push = await git.push({
@@ -105,8 +102,7 @@ export async function push (remoteUrl, branchRefspec, force) {
       throw new Error(push.errors.join(', '));
     }
     return push;
-  }
-  catch (e) {
+  } catch (e) {
     if (e.code === 'PushRejectedNonFastForward') {
       throw new Error('Push rejected because it was not a simple fast-forward. Use "--force" to override.');
     }
@@ -114,19 +110,18 @@ export async function push (remoteUrl, branchRefspec, force) {
   }
 }
 
-export function completeBranches () {
+export function completeBranches() {
   return getRepo()
     .then((repo) => git.listBranches(repo))
     .then(cliparse.autocomplete.words);
 }
 
-export async function isShallow () {
+export async function isShallow() {
   const { dir } = await getRepo();
   try {
     await fs.promises.access(path.join(dir, '.git', 'shallow'));
     return true;
-  }
-  catch (e) {
+  } catch {
     return false;
   }
 }
@@ -135,7 +130,7 @@ export async function isShallow () {
  * Check if the current directory is a git repository
  * @returns {Promise<boolean>}
  */
-export async function isInsideGitRepo () {
+export async function isInsideGitRepo() {
   return getRepo()
     .then(() => true)
     .catch(() => false);
@@ -145,16 +140,15 @@ export async function isInsideGitRepo () {
  * Check if the current git working directory is clean
  * @returns {Promise<boolean>}
  */
-export async function isGitWorkingDirectoryClean () {
+export async function isGitWorkingDirectoryClean() {
   const repo = await getRepo();
   const status = await git.statusMatrix({ ...repo });
-  const isStatusEmpty = status
-    .filter(([filepath, head, workdir]) => {
+  const isStatusEmpty =
+    status.filter(([filepath, head, workdir]) => {
       // WARNING: isomorphic-git does not support global gitignore so we filter hidden files and dirs to reduce the amount of false positives
       const isHidden = filepath.startsWith('.');
       const isCleverJson = filepath === '.clever.json';
       return (!isHidden || isCleverJson) && head !== workdir;
-    })
-    .length === 0;
+    }).length === 0;
   return isStatusEmpty;
 }

package/src/models/ids-resolver.js

@@ -1,7 +1,7 @@
-import { Logger } from '../logger.js';
-import { sendToApi } from './send-to-api.js';
 import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
+import { Logger } from '../logger.js';
 import { loadIdsCache, writeIdsCache } from './configuration.js';
+import { sendToApi } from './send-to-api.js';
 
 /*
 This system uses a simplified representation of the summary to expose IDs links:
@@ -25,14 +25,13 @@ This system uses a simplified representation of the summary to expose IDs links:
 }
  */
 
-export async function resolveOwnerId (id) {
+export async function resolveOwnerId(id) {
   return getIdFromCacheOrSummary((ids) => ids.owners[id]);
 }
 
-export async function resolveAddonId (id) {
-
+export async function resolveAddonId(id) {
   const addonId = await getIdFromCacheOrSummary((ids) => {
-    return (ids.addons[id] != null) ? ids.addons[id].addonId : null;
+    return ids.addons[id] != null ? ids.addons[id].addonId : null;
   });
 
   if (addonId != null) {
@@ -42,10 +41,9 @@ export async function resolveAddonId (id) {
   throw new Error(`Add-on ${id} does not exist`);
 }
 
-export async function resolveRealId (id) {
-
+export async function resolveRealId(id) {
   const realId = await getIdFromCacheOrSummary((ids) => {
-    return (ids.addons[id] != null) ? ids.addons[id].realId : null;
+    return ids.addons[id] != null ? ids.addons[id].realId : null;
   });
 
   if (realId != null) {
@@ -55,8 +53,7 @@ export async function resolveRealId (id) {
   throw new Error(`Add-on ${id} does not exist foo`);
 }
 
-async function getIdFromCacheOrSummary (callback) {
-
+async function getIdFromCacheOrSummary(callback) {
   const idsFromCache = await loadIdsCache();
   const idFromCache = callback(idsFromCache);
   if (idFromCache != null) {
@@ -74,8 +71,7 @@ async function getIdFromCacheOrSummary (callback) {
   return null;
 }
 
-async function getIdsFromSummary () {
-
+async function getIdsFromSummary() {
   const ids = {
     owners: {},
     addons: {},
@@ -83,10 +79,7 @@ async function getIdsFromSummary () {
 
   const summary = await getSummary().then(sendToApi);
 
-  const owners = [
-    summary.user,
-    ...summary.organisations,
-  ];
+  const owners = [summary.user, ...summary.organisations];
 
   for (const owner of owners) {
     for (const app of owner.applications) {
@@ -112,19 +105,21 @@ async function getIdsFromSummary () {
  * @throws {Error} if several add-ons are found
  * @returns {Object} The name, IDs and owner ID of the add-on { name, addonId, realId, ownerId }
  */
-export async function findAddonsByNameOrId (addonIdOrRealIdOrName, ownerNameOrId) {
+export async function findAddonsByNameOrId(addonIdOrRealIdOrName, ownerNameOrId) {
   const summary = await getSummary().then(sendToApi);
 
-  Logger.debug(`Searching for add-on '${addonIdOrRealIdOrName}' in ${summary.user.id} and ${summary.organisations.map((org) => org.id).join(', ')}`);
+  Logger.debug(
+    `Searching for add-on '${addonIdOrRealIdOrName}' in ${summary.user.id} and ${summary.organisations.map((org) => org.id).join(', ')}`,
+  );
   const candidates = [summary.user, ...summary.organisations]
     .flatMap((owner) => owner.addons.map((addon) => ({ addon, owner })))
     .filter(({ addon, owner }) => {
-      const matchOwner = ownerNameOrId == null
-        || owner.id === ownerNameOrId.orga_id
-        || owner.name === ownerNameOrId.orga_name;
-      const matchAddon = addon.name === addonIdOrRealIdOrName
-        || addon.realId === addonIdOrRealIdOrName
-        || addon.id === addonIdOrRealIdOrName;
+      const matchOwner =
+        ownerNameOrId == null || owner.id === ownerNameOrId.orga_id || owner.name === ownerNameOrId.orga_name;
+      const matchAddon =
+        addon.name === addonIdOrRealIdOrName ||
+        addon.realId === addonIdOrRealIdOrName ||
+        addon.id === addonIdOrRealIdOrName;
       return matchOwner && matchAddon;
     })
     .map(({ addon, owner }) => ({
@@ -149,24 +144,25 @@ export async function findAddonsByNameOrId (addonIdOrRealIdOrName, ownerNameOrId
  * @throws {Error} if several add-ons are found
  * @returns {Object} The name, IDs and owner ID of the add-on { name, addonId, realId, ownerId }
  */
-export async function findAddonsByAddonProvider (provider) {
+export async function findAddonsByAddonProvider(provider) {
   const summary = await getSummary().then(sendToApi);
 
-  Logger.debug(`Searching for ${provider} add-ons in ${summary.user.id} and ${summary.organisations.map((org) => org.id).join(', ')}`);
-  const candidates = [summary.user, ...summary.organisations]
-    .flatMap((owner) => {
-      return owner.addons
-        .filter((addon) => addon.providerId === provider)
-        .map((addon) => {
-          return {
-            name: addon.name,
-            addonId: addon.id,
-            realId: addon.realId,
-            ownerId: owner.id,
-            ownerName: owner.name,
-          };
-        });
-    });
+  Logger.debug(
+    `Searching for ${provider} add-ons in ${summary.user.id} and ${summary.organisations.map((org) => org.id).join(', ')}`,
+  );
+  const candidates = [summary.user, ...summary.organisations].flatMap((owner) => {
+    return owner.addons
+      .filter((addon) => addon.providerId === provider)
+      .map((addon) => {
+        return {
+          name: addon.name,
+          addonId: addon.id,
+          realId: addon.realId,
+          ownerId: owner.id,
+          ownerName: owner.name,
+        };
+      });
+  });
 
   Logger.debug(`Found ${candidates.length} candidate(s) for provider ${provider}:`);
   for (const candidate of candidates) {

package/src/models/isomorphic-http-with-agent.js

@@ -1,4 +1,4 @@
-import isomotphicHttp from 'isomorphic-git/http/node/index.js';
+import * as git from 'isomorphic-git/http/node';
 import https from 'node:https';
 
 // We use our own HTTP plugin, so we can customize the agent used for requests and configure a long timeout (default is 5 seconds).
@@ -8,6 +8,6 @@ const agent = new https.Agent({
   timeout: 10 * 60 * 1000,
 });
 
-export function request (params) {
-  return isomotphicHttp.request({ ...params, agent });
+export function request(params) {
+  return git.request({ ...params, agent });
 }

package/src/models/json-array.js

@@ -2,25 +2,24 @@
  * Helper to print a real JSON array with starting `[` and ending `]`
  */
 export class JsonArray {
-  constructor () {
+  constructor() {
     this._isFirst = true;
   }
 
-  open () {
+  open() {
     process.stdout.write('[\n');
   }
 
-  push (log) {
+  push(log) {
     if (this._isFirst) {
       this._isFirst = false;
-    }
-    else {
+    } else {
       process.stdout.write(',\n');
     }
     process.stdout.write(`  ${JSON.stringify(log)}`);
   }
 
-  close () {
+  close() {
     process.stdout.write('\n]');
   }
 }