clever-tools 3.8.3 → 3.9.0

package/src/commands/deploy.js

@@ -1,19 +1,17 @@
-'use strict';
+import colors from 'colors/safe.js';
 
-const colors = require('colors/safe');
-
-const AppConfig = require('../models/app_configuration.js');
-const Application = require('../models/application.js');
-const git = require('../models/git.js');
-const Log = require('../models/log-v4.js');
-const Logger = require('../logger.js');
-const { getAllDeployments } = require('@clevercloud/client/cjs/api/v2/application.js');
-const { sendToApi } = require('../models/send-to-api.js');
-const ExitStrategy = require('../models/exit-strategy-option.js');
+import * as AppConfig from '../models/app_configuration.js';
+import * as Application from '../models/application.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)
-async function deploy (params) {
+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);
@@ -105,5 +103,3 @@ async function getBranchToDeploy (branchName, tagName) {
     return await git.getFullBranch(branchName);
   }
 }
-
-module.exports = { deploy };

package/src/commands/diag.js

@@ -1,16 +1,16 @@
-'use strict';
+import os from 'node:os';
 
-const os = require('os');
+import { releaseInfo as getLinuxInfos } from 'linux-release-info';
+import colors from 'colors/safe.js';
 
-const { releaseInfo: getLinuxInfos } = require('linux-release-info');
-const colors = require('colors/safe');
+import { Logger } from '../logger.js';
+import { getPackageJson } from '../load-package-json.cjs';
+import * as User from '../models/user.js';
+import { conf, loadOAuthConf } from '../models/configuration.js';
 
-const Logger = require('../logger.js');
-const pkg = require('../../package.json');
-const User = require('../models/user.js');
-const { conf, loadOAuthConf } = require('../models/configuration.js');
+const pkg = getPackageJson();
 
-async function diag (params) {
+export async function diag (params) {
   const { format } = params.options;
 
   /** @type {string} */
@@ -93,5 +93,3 @@ async function diag (params) {
     }
   }
 }
-
-module.exports = { diag };

package/src/commands/domain.js

@@ -1,16 +1,28 @@
-'use strict';
-
-const Application = require('../models/application.js');
-const Logger = require('../logger.js');
-const {
-  get: getApp,
+import * as Application from '../models/application.js';
+import { Logger } from '../logger.js';
+import {
   addDomain,
-  getFavouriteDomain: getFavouriteDomainWithError,
+  get as getApp,
+  getAllDomains,
+  getFavouriteDomain as getFavouriteDomainWithError,
   markFavouriteDomain,
-  unmarkFavouriteDomain,
   removeDomain,
-} = require('@clevercloud/client/cjs/api/v2/application.js');
-const { sendToApi } = require('../models/send-to-api.js');
+  unmarkFavouriteDomain,
+} from '@clevercloud/client/esm/api/v2/application.js';
+import { getSummary } from '@clevercloud/client/cjs/api/v2/user.js';
+import { sendToApi } from '../models/send-to-api.js';
+import colors from 'colors/safe.js';
+import { parse as parseDomain } from 'tldts';
+import { diagDomainConfig } from '@clevercloud/client/esm/utils/diag-domain-config.js';
+import { sortDomains } from '@clevercloud/client/esm/utils/domains.js';
+import { DnsResolver } from '../models/node-dns-resolver.js';
+import _ from 'lodash';
+
+/**
+ * @typedef {import('@clevercloud/client/esm/utils/diag-domain-config.types.js').DomainInfo} DomainInfo
+ * @typedef {import('@clevercloud/client/esm/utils/diag-domain-config.types.js').ResolveDnsResult} ResolveDnsResult
+ * @typedef {import('@clevercloud/client/esm/utils/diag-domain-config.types.js').DomainDiag} DomainDiag
+ */
 
 function getFavouriteDomain ({ ownerId, appId }) {
   return getFavouriteDomainWithError({ id: ownerId, appId })
@@ -25,7 +37,7 @@ function getFavouriteDomain ({ ownerId, appId }) {
     });
 }
 
-async function list (params) {
+export async function list (params) {
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
@@ -39,7 +51,7 @@ async function list (params) {
   });
 }
 
-async function add (params) {
+export async function add (params) {
   const [fqdn] = params.args;
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
@@ -49,7 +61,7 @@ async function add (params) {
   Logger.println('Your domain has been successfully saved');
 }
 
-async function getFavourite (params) {
+export async function getFavourite (params) {
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
@@ -62,7 +74,7 @@ async function getFavourite (params) {
   return Logger.println(favouriteDomain);
 }
 
-async function setFavourite (params) {
+export async function setFavourite (params) {
   const [fqdn] = params.args;
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
@@ -71,7 +83,7 @@ async function setFavourite (params) {
   Logger.println('Your favourite domain has been successfully set');
 }
 
-async function unsetFavourite (params) {
+export async function unsetFavourite (params) {
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
@@ -79,7 +91,7 @@ async function unsetFavourite (params) {
   Logger.println('Favourite domain has been successfully unset');
 }
 
-async function rm (params) {
+export async function rm (params) {
   const [fqdn] = params.args;
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
@@ -89,4 +101,323 @@ async function rm (params) {
   Logger.println('Your domain has been successfully removed');
 }
 
-module.exports = { list, add, getFavourite, setFavourite, unsetFavourite, rm };
+export async function diagApplication (params) {
+  const dnsResolver = new DnsResolver();
+  const allDomainDiagnostics = [];
+  const { alias, app: appIdOrName, format, filter } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+  const hasDomainFilter = filter.length > 0;
+  let hasError = false;
+
+  const app = await getApp({ id: ownerId, appId }).then(sendToApi);
+  const expectedDnsForPublicLoadBalancer = await getDefaultLoadBalancersDnsInfo({ id: ownerId, appId }).then(sendToApi);
+
+  const loadBalancerDnsConfig = {
+    aRecords: expectedDnsForPublicLoadBalancer[0].dns.a,
+    cnameRecord: expectedDnsForPublicLoadBalancer[0].dns.cname,
+  };
+
+  const filteredDomains = app.vhosts.filter(({ fqdn }) => fqdn.includes(filter));
+  const domains = getParsedDomains(filteredDomains);
+  const sortedDomains = domains.sort(sortDomains);
+
+  for (const { hostname, pathPrefix, isApex } of sortedDomains) {
+    const resolvedDnsConfig = {
+      aRecords: await dnsResolver.resolveA(hostname),
+      cnameRecords: await dnsResolver.resolveCname(hostname) ?? [],
+    };
+
+    const diagnosticResults = diagDomainConfig({
+      hostname,
+      pathPrefix,
+      isApex,
+    }, resolvedDnsConfig, loadBalancerDnsConfig);
+    allDomainDiagnostics.push({ ...diagnosticResults, resolvedDnsConfig });
+
+    if (diagnosticResults.diagSummary === 'invalid' || diagnosticResults.diagSummary === 'no-config') {
+      hasError = true;
+    }
+  }
+
+  switch (format) {
+    case 'json':
+      Logger.printJson(allDomainDiagnostics);
+      break;
+    default: {
+      allDomainDiagnostics.forEach((diag) => reportDomainDiagnostics(diag));
+
+      if (allDomainDiagnostics.length === 0 && !hasDomainFilter) {
+        Logger.println(`\nNo domain associated to the app "${app.name}" (${app.id})`);
+      }
+
+      if (allDomainDiagnostics.length === 0 && hasDomainFilter) {
+        Logger.println(`\nNo domain matches "${filter}" for the app "${app.name}" (${app.id})`);
+      }
+    }
+  }
+
+  if (hasError) {
+    throw new Error('At least one of the domains is misconfigured');
+  }
+}
+
+export async function overview (params) {
+
+  const { format, filter } = params.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);
+      return { app, domains };
+    }),
+  );
+
+  const applicationsWithParsedDomain = applicationsWithDomains
+    .flatMap(({ app, domains }) => {
+      return domains
+        .filter((domain) => filter == null || domain.fqdn.includes(filter))
+        .map((domain) => {
+
+          const parsedDomain = parseDomain(domain.fqdn);
+          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;
+  }
+}
+
+/** @param {DomainDiag & { resolvedDnsConfig: ResolveDnsResult }} domainDiag */
+function reportDomainDiagnostics ({ hostname, pathPrefix, resolvedDnsConfig, diagDetails, diagSummary }) {
+
+  const validDiags = diagDetails.filter((diag) => diag.code === 'valid-a');
+  const unknownDiags = diagDetails.filter((diag) => diag.code === 'unknown-a');
+  const missingDiags = diagDetails.filter((diag) => diag.code === 'missing-a');
+  const suggestedCname = diagDetails.find((diag) => diag.code === 'suggested-cname');
+  const missingCname = diagDetails.find((diag) => diag.code === 'missing-cname');
+  const unknownCname = diagDetails.find((diag) => diag.code === 'unknown-cname');
+
+  const hasARecords = resolvedDnsConfig.aRecords.length > 0;
+  const hasCnameRecord = resolvedDnsConfig.cnameRecords.length > 0;
+
+  Logger.println('\n' + colors.blue(hostname) + colors.yellow(pathPrefix) + '\n');
+
+  switch (diagSummary) {
+    case 'managed':
+      printlnWithIndent(colors.green('✔ Managed by Clever Cloud'), 2);
+      printlnWithIndent('ⓘ cleverapps.io domains should only be used for testing purposes', 2);
+      break;
+    case 'no-config':
+      printlnWithIndent(colors.red('✘ No DNS configuration found'), 2);
+      break;
+    case 'valid':
+      printlnWithIndent(colors.green('✔ Your configuration is valid'), 2);
+      break;
+    case 'invalid':
+      printlnWithIndent(colors.red('✘ Something is wrong with your configuration'), 2);
+      break;
+    case 'incomplete':
+      printlnWithIndent(colors.yellow('⚠ Your configuration is incomplete'), 2);
+      break;
+  }
+
+  // Valid records
+  if (validDiags.length > 0) {
+    Logger.println('');
+    validDiags.forEach((diag) => {
+      const source = hasCnameRecord ? `(from CNAME ${resolvedDnsConfig.cnameRecords[0]}.)` : '';
+      printlnWithIndent(`${diag.record.value} ${colors.green('✔ A Record OK')} ${source}`, 2);
+    });
+  }
+
+  // Replace A with CNAME
+  if (diagSummary === 'valid' && suggestedCname != null) {
+    Logger.println('');
+    printlnWithIndent('ⓘ You can replace your A records with this CNAME:', 2);
+    printlnWithIndent(suggestedCname.record.value, 6);
+  }
+
+  // Replace A Records with CNAME
+  if (missingCname != null && unknownCname == null && (diagSummary === 'invalid' || diagSummary === 'incomplete')) {
+    const cnameToUse = suggestedCname != null ? suggestedCname.record.value : missingCname.record.value;
+
+    Logger.println('');
+    printlnWithIndent('⇄ Replace your A records with this CNAME:', 2);
+    printlnWithIndent(cnameToUse, 6);
+    Logger.println('');
+    printlnWithIndent('or:', 2);
+  }
+
+  // Replace unknown CNAME with missing CNAME
+  if ((diagSummary === 'invalid') && missingCname != null && unknownCname != null) {
+    Logger.println('');
+    printlnWithIndent('➖Remove this CNAME record:', 2);
+    printlnWithIndent(unknownCname.record.value + '. ', 6);
+    Logger.println('');
+    printlnWithIndent('➕Add this CNAME record instead:', 2);
+    printlnWithIndent(missingCname.record.value, 6);
+
+    if (hasARecords) {
+      Logger.println('');
+      printlnWithIndent('or:', 2);
+    }
+  }
+
+  // Add CNAME
+  if (diagSummary === 'no-config' && missingCname != null) {
+    Logger.println('');
+    printlnWithIndent('➕Add this CNAME record:', 2);
+    printlnWithIndent(missingCname.record.value, 6);
+  }
+
+  // Remove Unknown records
+  if (unknownDiags.length > 0) {
+    Logger.println('');
+    printlnWithIndent('➖Remove these A records:', 2);
+
+    unknownDiags.forEach((diag) => {
+      const source = hasCnameRecord ? `(from CNAME ${resolvedDnsConfig.cnameRecords[0]}.)` : '';
+      printlnWithIndent(diag.record.value + source, 6);
+    });
+  }
+
+  // Add missing A records
+  if (missingDiags.length > 0) {
+    Logger.println('');
+    printlnWithIndent('➕Add these A records:', 2);
+
+    missingDiags.forEach((missingDiag) => printlnWithIndent(missingDiag.record.value, 6));
+  }
+}
+
+// TODO: put in clever client
+function getDefaultLoadBalancersDnsInfo (params) {
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/load-balancers/organisations/${params.id}/applications/${params.appId}/load-balancers/default`,
+    headers: {
+      Accept: 'application/json',
+    },
+    // no query params
+    // no body
+  });
+}
+
+/**
+ * Parses domain information from vhosts array
+ *
+ * @param {Array<{ fqdn: string }>} vhosts
+ * @returns {Array<Partial<DomainInfo>>} Array of parsed domain objects
+ */
+function getParsedDomains (vhosts) {
+  return vhosts.map(({ fqdn }) => {
+    const { hostname, pathname } = new URL('https://' + fqdn);
+    const { subdomain } = parseDomain(fqdn);
+
+    return { hostname, pathPrefix: pathname, isApex: subdomain === '' };
+  });
+}
+
+/**
+ * Prints a line of text with specified indentation.
+ *
+ * @param {string} text - The text to be printed.
+ * @param {number} indentLevel - The number of spaces to indent the text.
+ */
+function printlnWithIndent (text, indentLevel) {
+  Logger.println(' '.repeat(indentLevel) + text);
+}
+
+function recursiveSort (obj) {
+
+  if (typeof obj === 'object' && obj.appId != null) {
+    return obj;
+  }
+
+  const sortedObj = {};
+  Object.keys(obj).sort((a, b) => a.localeCompare(b)).forEach((key) => {
+    sortedObj[key] = recursiveSort(obj[key]);
+  });
+
+  return sortedObj;
+}
+
+function recursiveDisplay (obj, indentLevel = 0) {
+
+  if (typeof obj === 'object' && obj.appId != null) {
+    printlnWithIndent(`${obj.ownerName} | ${obj.appName} (${obj.appVariantSlug})`, indentLevel);
+    printlnWithIndent(colors.blue(obj.appConsoleUrl), indentLevel);
+    return;
+  }
+
+  for (const [propertyPath, subObj] of Object.entries(obj)) {
+    if (propertyPath !== '/') {
+      Logger.println('');
+      printlnWithIndent(colors.yellow(propertyPath), indentLevel);
+      recursiveDisplay(subObj, indentLevel + 2);
+    }
+    else {
+      recursiveDisplay(subObj, indentLevel);
+    }
+  }
+}

package/src/commands/drain.js

@@ -1,11 +1,9 @@
-'use strict';
+import * as Application from '../models/application.js';
+import { createDrainBody } from '../models/drain.js';
+import { Logger } from '../logger.js';
 
-const Application = require('../models/application.js');
-const { createDrainBody } = require('../models/drain.js');
-const Logger = require('../logger.js');
-
-const { getDrains, createDrain, deleteDrain, updateDrainState } = require('@clevercloud/client/cjs/api/v2/log.js');
-const { sendToApi } = require('../models/send-to-api.js');
+import { getDrains, createDrain, deleteDrain, updateDrainState } from '@clevercloud/client/esm/api/v2/log.js';
+import { sendToApi } from '../models/send-to-api.js';
 
 // TODO: This could be useful in other commands
 async function getAppOrAddonId ({ alias, appIdOrName, addonId }) {
@@ -14,7 +12,7 @@ async function getAppOrAddonId ({ alias, appIdOrName, addonId }) {
     : await Application.resolveId(appIdOrName, alias).then(({ appId }) => appId);
 }
 
-async function list (params) {
+export async function list (params) {
   const { alias, app: appIdOrName, addon: addonId, format } = params.options;
 
   const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
@@ -54,7 +52,7 @@ async function list (params) {
   }
 }
 
-async function create (params) {
+export async function create (params) {
   const [drainTargetType, drainTargetURL] = params.args;
   const { alias, app: appIdOrName, addon: addonId, username, password, 'api-key': apiKey, 'index-prefix': indexPrefix, 'sd-params': structuredDataParameters } = params.options;
   const drainTargetCredentials = { username, password };
@@ -67,7 +65,7 @@ async function create (params) {
   Logger.println('Your drain has been successfully saved');
 }
 
-async function rm (params) {
+export async function rm (params) {
   const [drainId] = params.args;
   const { alias, app: appIdOrName, addon: addonId } = params.options;
 
@@ -77,7 +75,7 @@ async function rm (params) {
   Logger.println('Your drain has been successfully removed');
 }
 
-async function enable (params) {
+export async function enable (params) {
   const [drainId] = params.args;
   const { alias, app: appIdOrName, addon: addonId } = params.options;
 
@@ -87,7 +85,7 @@ async function enable (params) {
   Logger.println('Your drain has been enabled');
 }
 
-async function disable (params) {
+export async function disable (params) {
   const [drainId] = params.args;
   const { alias, app: appIdOrName, addon: addonId } = params.options;
 
@@ -96,11 +94,3 @@ async function disable (params) {
 
   Logger.println('Your drain has been disabled');
 }
-
-module.exports = {
-  list,
-  create,
-  rm,
-  enable,
-  disable,
-};

package/src/commands/env.js

@@ -1,14 +1,12 @@
-'use strict';
-
-const Application = require('../models/application.js');
-const Logger = require('../logger.js');
-const colors = require('colors/safe');
-const variables = require('../models/variables.js');
-const { sendToApi } = require('../models/send-to-api.js');
-const { toNameEqualsValueString, validateName } = require('@clevercloud/client/cjs/utils/env-vars.js');
-const application = require('@clevercloud/client/cjs/api/v2/application.js');
-
-async function list (params) {
+import * as Application from '../models/application.js';
+import { Logger } from '../logger.js';
+import colors from 'colors/safe.js';
+import * as variables from '../models/variables.js';
+import { sendToApi } from '../models/send-to-api.js';
+import { toNameEqualsValueString, validateName } from '@clevercloud/client/esm/utils/env-vars.js';
+import * as application from '@clevercloud/client/esm/api/v2/application.js';
+
+export async function list (params) {
   const { alias, app: appIdOrName, 'add-export': addExportsOption, format } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
@@ -60,7 +58,7 @@ async function list (params) {
   }
 }
 
-async function set (params) {
+export async function set (params) {
   const [envName, value] = params.args;
   const { alias, app: appIdOrName } = params.options;
 
@@ -76,7 +74,7 @@ async function set (params) {
   Logger.println('Your environment variable has been successfully saved');
 };
 
-async function rm (params) {
+export async function rm (params) {
   const [envName] = params.args;
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
@@ -86,7 +84,7 @@ async function rm (params) {
   Logger.println('Your environment variable has been successfully removed');
 };
 
-async function importEnv (params) {
+export async function importEnv (params) {
   const { alias, app: appIdOrName, json } = params.options;
   const format = json ? 'json' : 'name-equals-value';
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
@@ -97,7 +95,7 @@ async function importEnv (params) {
   Logger.println('Environment variables have been set');
 };
 
-async function importVarsFromLocalEnv (params) {
+export async function importVarsFromLocalEnv (params) {
   const [envNames] = params.args;
   const { alias, app: appIdOrName } = params.options;
 
@@ -117,5 +115,3 @@ async function importVarsFromLocalEnv (params) {
 
   Logger.println('Your environment variables have been successfully saved');
 };
-
-module.exports = { list, set, rm, importEnv, importVarsFromLocalEnv };

package/src/commands/link.js

@@ -1,9 +1,7 @@
-'use strict';
+import * as Application from '../models/application.js';
+import { Logger } from '../logger.js';
 
-const Application = require('../models/application.js');
-const Logger = require('../logger.js');
-
-async function link (params) {
+export async function link (params) {
   const [app] = params.args;
   const { org: orgaIdOrName, alias } = params.options;
 
@@ -15,5 +13,3 @@ async function link (params) {
 
   Logger.println('Your application has been successfully linked!');
 }
-
-module.exports = { link };