clever-tools 3.11.0 → 3.13.0

package/src/lib/operator-commands.js

@@ -0,0 +1,281 @@
+import colors from 'colors/safe.js';
+import _ from 'lodash';
+import dedent from 'dedent';
+
+import * as Operator from '../models/operator.js';
+
+import { Logger } from '../logger.js';
+import { sendToApi } from '../models/send-to-api.js';
+import {
+  ngDisableOperator,
+  ngEnableOperator,
+  rebootOperator,
+  rebuildOperator,
+  versionCheck,
+  versionUpdate,
+} from '../clever-client/operators.js';
+import { findAddonsByAddonProvider } from '../models/ids-resolver.js';
+import { openBrowser } from '../models/utils.js';
+import { confirm, selectAnswer } from './prompts.js';
+import { conf } from '../models/configuration.js';
+
+/**
+ * Check the version of an operator
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @param {string} params.options.format The output format
+ * @returns {Promise<void>}
+ */
+export async function operatorCheckVersion (provider, addonIdOrName, format) {
+
+  const realId = await Operator.getSingleRealId(addonIdOrName);
+  const name = getDisplayName(addonIdOrName);
+  const versions = await versionCheck({ provider, realId }).then(sendToApi);
+
+  switch (format) {
+    case 'json':
+      Logger.printJson(versions);
+      break;
+    case 'human':
+    default:
+      if (!versions.needUpdate || (provider === 'metabase' && versions.installed === 'community-latest')) {
+        Logger.printSuccess(`${colors.green(name)} is up-to-date (${colors.green(versions.installed)})`);
+      }
+      else {
+        Logger.println(dedent`
+          🔄 ${colors.red(name)} is outdated
+             • Installed version: ${colors.red(versions.installed)}
+             • Latest version: ${colors.green(versions.latest)}
+        `);
+        Logger.println();
+
+        await confirm(
+          `Do you want to update it to ${colors.green(versions.latest)} now?`,
+          'No confirmation, aborting version update',
+        );
+
+        await versionUpdate({ provider, realId }, { targetVersion: versions.latest }).then(sendToApi);
+        Logger.printSuccess(`${colors.green(name)} is up-to-date and being rebuilt…`);
+      }
+      break;
+  }
+}
+
+/**
+ * Update the version of an operator
+ * @param {string} provider The operator's provider
+ * @param {string} askedVersion The version to update to
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function operatorUpdateVersion (provider, askedVersion, addonIdOrName) {
+  const realId = await Operator.getSingleRealId(addonIdOrName);
+  const name = getDisplayName(addonIdOrName);
+
+  const versions = await versionCheck({ provider, realId }).then(sendToApi);
+
+  const targetVersion = askedVersion ?? await selectAnswer(
+    `Which version do you want to update ${colors.blue(name)} to, current is ${colors.blue(versions.installed)}?`,
+    versions.available.reverse(),
+  );
+
+  if (!versions.available.includes(targetVersion)) {
+    throw new Error(`Version ${colors.red(targetVersion)} is not available`);
+  }
+
+  if (versions.installed === targetVersion) {
+    Logger.printSuccess(`${colors.green(name)} is already at version ${colors.green(targetVersion)}`);
+    return;
+  }
+
+  await versionUpdate({ provider, realId }, { targetVersion }).then(sendToApi);
+  Logger.printSuccess(`${colors.green(name)} updated to ${colors.green(targetVersion)} and being rebuilt…`);
+}
+
+/**
+ * Unlink an operator from a Network Group
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ * @throws {Error} If the Network Group feature is already disabled
+ */
+export async function operatorNgDisable (provider, addonIdOrName) {
+  const name = getDisplayName(addonIdOrName);
+  const operator = await Operator.getDetails(provider, addonIdOrName);
+  if (!operator.features.networkGroup?.id) {
+    throw new Error(`Network Group is already disabled on ${colors.red(name)}`);
+  }
+
+  await ngDisableOperator({ provider, realId: operator.resourceId }).then(sendToApi);
+  Logger.println(`Disabling Network Group on ${colors.blue(name)}…`);
+
+  await operatorPrint(provider, addonIdOrName);
+}
+
+/**
+ * Link an operator to a Network Group
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ * @throws {Error} If the Network Group feature is already enabled
+ */
+export async function operatorNgEnable (provider, addonIdOrName) {
+  const name = getDisplayName(addonIdOrName);
+  const operator = await Operator.getDetails(provider, addonIdOrName);
+
+  if (operator.features.networkGroup?.id) {
+    throw new Error(`Network Group is already enabled on ${colors.red(name)}`);
+  }
+
+  await ngEnableOperator({ provider, realId: operator.resourceId }).then(sendToApi);
+  Logger.println(`Enabling Network Group on ${colors.blue(name)}…`);
+
+  await operatorPrint(provider, addonIdOrName);
+}
+
+/**
+ * List all operators for a given provider
+ * @param {string} provider The operator's provider
+ * @param {string} format The output format
+ * @returns {Promise<void>}
+ */
+export async function operatorList (provider, format) {
+  const deployed = await findAddonsByAddonProvider(provider);
+  const providerName = _.capitalize(provider.replace('addon-', ''));
+  const operatorsPerOwner = _.groupBy(deployed, 'ownerId');
+
+  switch (format) {
+    case 'json':
+      Logger.printJson(operatorsPerOwner);
+      break;
+    case 'human':
+    default:
+
+      if (deployed.length === 0) {
+        Logger.println(`🔎 No ${providerName} found, create one with ${colors.blue(`clever addon create ${providerName.toLocaleLowerCase()}`)} command`);
+        return;
+      }
+
+      Logger.println(`🔎 Found ${deployed.length} ${providerName} operator${deployed.length > 1 ? 's' : ''}:`);
+      Logger.println();
+
+      Object.values(operatorsPerOwner).forEach((operators) => {
+        Logger.println(`• ${colors.bold(`${(operators[0].ownerId)} (${(operators[0].ownerName)})`)}`);
+        operators.forEach((operator) => {
+          Logger.println(`  • ${operator.name} ${colors.grey(`(${operator.realId})`)}`);
+        });
+        Logger.println();
+      });
+      break;
+  }
+}
+
+/**
+ * Open an operator dashboard in the Clever Cloud Console in the browser
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function operatorOpen (provider, addonIdOrName) {
+  const operator = await Operator.getDetails(provider, addonIdOrName);
+  await openBrowser(`${conf.GOTO_URL}/${operator.addonId}`, `🌐 Opening ${colors.blue(operator.addonId)} in the browser…`);
+}
+
+/**
+ * Open the Logs section of an operator application in the Clever Cloud Console
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function operatorOpenLogs (provider, addonIdOrName) {
+  const operator = await Operator.getDetails(provider, addonIdOrName);
+  await openBrowser(
+    `/organisations/${operator.ownerId}/applications/${operator.resources.entrypoint}/logs`,
+    `🌐 Opening ${colors.blue(operator.addonId)} logs in the Clever Cloud Console…`,
+  );
+}
+
+/**
+ * Open an operator Web UI in the browser
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function operatorOpenWebUi (provider, addonIdOrName) {
+  const operator = await Operator.getDetails(provider, addonIdOrName);
+  await openBrowser(operator.accessUrl, `🌐 Opening ${colors.blue(operator.addonId)} Management interface in the browser…`);
+}
+
+/**
+ * Reboot an operator
+ * @param {object} params The command's parameters
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function operatorReboot (provider, addonIdOrName) {
+  const name = getDisplayName(addonIdOrName);
+  const realId = await Operator.getSingleRealId(addonIdOrName);
+  await rebootOperator({ provider, realId }).then(sendToApi);
+  Logger.println(`🔄 Restarting ${colors.blue(name)}…`);
+}
+
+/**
+ * Rebuild an operator
+ * @param {object} params The command's parameters
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function operatorRebuild (provider, addonIdOrName) {
+  const name = getDisplayName(addonIdOrName);
+  const realId = await Operator.getSingleRealId(addonIdOrName);
+  await rebuildOperator({ provider, realId }).then(sendToApi);
+  Logger.println(`🔄 Rebuilding ${colors.blue(name)}…`);
+}
+
+/**
+ * Print the details of an operator
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @param {string} format The output format
+ * @returns {void}
+ */
+export async function operatorPrint (provider, addonIdOrName, format = 'human') {
+
+  const operator = await Operator.getDetails(provider, addonIdOrName);
+
+  const dataToPrint = {
+    Name: operator.name,
+    ID: operator.resourceId,
+    Owner: operator.ownerId,
+  };
+
+  dataToPrint.Version = provider === 'matomo'
+    ? `${operator.version} (PHP ${operator.phpVersion})`
+    : `${operator.version} (Java ${operator.javaVersion})`;
+
+  dataToPrint['Access URL'] = operator.accessUrl;
+
+  if (provider === 'otoroshi') {
+    dataToPrint['API URL'] = operator.api.url;
+  }
+
+  if (['otoroshi', 'keycloak'].includes(provider)) {
+    dataToPrint['Network Group'] = operator.features.networkGroup?.id ?? false;
+  }
+
+  switch (format) {
+    case 'json':
+      Logger.printJson(operator);
+      break;
+    case 'human':
+    default:
+      console.table(dataToPrint);
+      break;
+  }
+}
+
+function getDisplayName (addonIdOrName) {
+  return addonIdOrName.addon_name ?? addonIdOrName.operator_id ?? addonIdOrName.addon_id;
+}

package/src/lib/prompts.js

@@ -0,0 +1,30 @@
+import { confirm as confirmPrompt, input, password, select } from '@inquirer/prompts';
+
+export function promptSecret (message) {
+  return password({ message, mask: true }).catch(exitOnPromptError);
+}
+
+export async function confirm (message, rejectionMessage) {
+  const answer = await confirmPrompt({ message }).catch(exitOnPromptError);
+  if (!answer) {
+    throw new Error(rejectionMessage);
+  }
+}
+
+export async function confirmAnswer (message, rejectionMessage, expectedAnswer) {
+  const answer = await input({ message }).catch(exitOnPromptError);
+  if (answer !== expectedAnswer) {
+    throw new Error(rejectionMessage);
+  }
+}
+
+export function selectAnswer (message, choices) {
+  return select({ message, choices }).catch(exitOnPromptError);
+}
+
+function exitOnPromptError (error) {
+  if (error instanceof Error && error.name === 'ExitPromptError') {
+    process.exit(1);
+  }
+  throw error;
+}

package/src/lib/slugify.js

@@ -0,0 +1,10 @@
+import slugifyRaw from 'slugify';
+
+/**
+ * Converts a string to a slug using strict mode
+ * @param {string} string - The string to be converted to a slug
+ * @returns {string} The slugified string
+ */
+export function slugify (string) {
+  return slugifyRaw(string, { strict: true });
+}

package/src/logger.js

@@ -55,6 +55,9 @@ export const Logger = _(['debug', 'info', 'warn', 'error'])
 // No decoration for Logger.println
 Logger.println = console.log;
 
+// Logger for success with a green check before the message
+Logger.printSuccess = (message) => console.log(`${colors.bold.green('✓')} ${message}`);
+
 // No decoration for Logger.println
 Logger.printJson = (obj) => {
   console.log(JSON.stringify(obj, null, 2));

package/src/models/activity.js

@@ -1,8 +1,7 @@
-import * as application from '@clevercloud/client/esm/api/v2/application.js';
-
 import { sendToApi } from './send-to-api.js';
+import { getAllDeployments } from '@clevercloud/client/esm/api/v2/application.js';
 
 export function list (ownerId, appId, showAll) {
   const limit = showAll ? null : 10;
-  return application.getAllDeployments({ id: ownerId, appId, limit }).then(sendToApi);
+  return getAllDeployments({ id: ownerId, appId, limit }).then(sendToApi);
 };

package/src/models/addon.js

@@ -1,4 +1,3 @@
-import * as application from '@clevercloud/client/esm/api/v2/application.js';
 import cliparse from 'cliparse';
 
 import { get as getAddon, getAll as getAllAddons, getAllEnvVars, remove as removeAddon, create as createAddon, update as updateAddon } from '@clevercloud/client/esm/api/v2/addon.js';
@@ -6,10 +5,11 @@ import { getAllAddonProviders } from '@clevercloud/client/esm/api/v2/product.js'
 import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
 import { getAddonProvider } from '@clevercloud/client/esm/api/v4/addon-providers.js';
 
-import * as Interact from './interact.js';
+import { confirm } from '../lib/prompts.js';
 import { Logger } from '../logger.js';
 import { sendToApi } from '../models/send-to-api.js';
 import { resolveOwnerId } from './ids-resolver.js';
+import { getAllLinkedAddons, linkAddon, unlinkAddon } from '@clevercloud/client/esm/api/v2/application.js';
 
 export function listProviders () {
   return getAllAddonProviders({}).then(sendToApi);
@@ -42,7 +42,7 @@ export async function list (ownerId, appId, showAll) {
     return allAddons;
   }
 
-  const myAddons = await application.getAllLinkedAddons({ id: ownerId, appId }).then(sendToApi);
+  const myAddons = await getAllLinkedAddons({ id: ownerId, appId }).then(sendToApi);
 
   if (showAll == null) {
     return myAddons;
@@ -191,19 +191,22 @@ async function getId (ownerId, addon) {
 
 export async function link (ownerId, appId, addon) {
   const addonId = await getId(ownerId, addon);
-  return application.linkAddon({ id: ownerId, appId }, JSON.stringify(addonId)).then(sendToApi);
+  return linkAddon({ id: ownerId, appId }, JSON.stringify(addonId)).then(sendToApi);
 }
 
 export async function unlink (ownerId, appId, addon) {
   const addonId = await getId(ownerId, addon);
-  return application.unlinkAddon({ id: ownerId, appId, addonId }).then(sendToApi);
+  return unlinkAddon({ id: ownerId, appId, addonId }).then(sendToApi);
 }
 
 export async function deleteAddon (ownerId, addonIdOrName, skipConfirmation) {
   const addonId = await getId(ownerId, addonIdOrName);
 
   if (!skipConfirmation) {
-    await Interact.confirm('Deleting the addon can\'t be undone, are you sure? ', 'No confirmation, aborting addon deletion');
+    await confirm(
+      'Deleting the add-on can\'t be undone, are you sure?',
+      'No confirmation, aborting add-on deletion',
+    );
   }
 
   return removeAddon({ id: ownerId, addonId }).then(sendToApi);

package/src/models/app_configuration.js

@@ -2,7 +2,7 @@ import { promises as fs } from 'node:fs';
 import path from 'node:path';
 
 import _ from 'lodash';
-import slugify from 'slugify';
+import { slugify } from '../lib/slugify.js';
 
 import { Logger } from '../logger.js';
 import * as User from './user.js';
@@ -54,19 +54,22 @@ export async function addLinkedApplication (appData, alias, ignoreParentConfig)
 
 export async function removeLinkedApplication ({ appId, alias }) {
   const currentConfig = await loadApplicationConf();
+  const appToUnlink = currentConfig.apps.find((a) => a.app_id === appId || a.alias === alias);
+  if (appToUnlink == null) {
+    return false;
+  }
   const newConfig = {
     ...currentConfig,
-    apps: currentConfig.apps.filter((appEntry) => {
-      return appEntry.app_id !== appId && appEntry.alias !== alias;
-    }),
+    apps: currentConfig.apps.filter((a) => a !== appToUnlink),
   };
 
-  if (currentConfig.apps.length !== newConfig.apps.length) {
-    await persistConfig(newConfig);
-    return true;
+  const isDefault = currentConfig.default === appToUnlink.app_id;
+  if (isDefault) {
+    delete newConfig.default;
   }
 
-  return false;
+  await persistConfig(newConfig);
+  return true;
 };
 
 export function findApp (config, alias) {
@@ -134,7 +137,7 @@ async function getAppDetailsForId (appId) {
   }
   if (secondAppById != null) {
     throw new Error(`There are several applications matching id '${appId}'.`
-                  + 'This should not happen, your `.clever.json` should be fixed.');
+      + 'This should not happen, your `.clever.json` should be fixed.');
   }
 
   return appById;

package/src/models/application.js

@@ -1,23 +1,34 @@
 import _ from 'lodash';
-import * as application from '@clevercloud/client/esm/api/v2/application.js';
+import {
+  addDependency,
+  create as createApplication,
+  get as getApplication,
+  getAll as getAllApplications,
+  getAllDependencies,
+  redeploy as redeployApplication,
+  remove as removeApplication,
+  removeDependency,
+  update as updateApplication,
+} from '@clevercloud/client/esm/api/v2/application.js';
 import cliparse from 'cliparse';
-import * as product from '@clevercloud/client/esm/api/v2/product.js';
 import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
+import colors from 'colors/safe.js';
 
 import * as AppConfiguration from './app_configuration.js';
-import * as Interact from './interact.js';
+import { confirmAnswer } from '../lib/prompts.js';
 import { Logger } from '../logger.js';
 import * as Organisation from './organisation.js';
 import * as User from './user.js';
 
 import { sendToApi } from '../models/send-to-api.js';
 import { resolveOwnerId } from './ids-resolver.js';
+import { getAvailableInstances } from '@clevercloud/client/esm/api/v2/product.js';
 
 export function listAvailableTypes () {
-  return cliparse.autocomplete.words(['docker', 'elixir', 'go', 'gradle', 'haskell', 'jar', 'maven', 'meteor', 'node', 'php', 'play1', 'play2', 'python', 'ruby', 'rust', 'sbt', 'static-apache', 'war']);
+  return cliparse.autocomplete.words(['docker', 'elixir', 'frankenphp', 'go', 'gradle', 'haskell', 'jar', 'linux', 'maven', 'meteor', 'node', 'php', 'play1', 'play2', 'python', 'ruby', 'rust', 'sbt', 'static', 'static-apache', 'v', 'war']);
 };
 
-export const AVAILABLE_ZONES = ['par', 'grahds', 'rbx', 'rbxhds', 'scw', 'mtl', 'sgp', 'syd', 'wsw'];
+export const AVAILABLE_ZONES = ['par', 'parhds', 'grahds', 'rbx', 'rbxhds', 'scw', 'ldn', 'mtl', 'sgp', 'syd', 'wsw'];
 
 export function listAvailableZones () {
   return cliparse.autocomplete.words(AVAILABLE_ZONES);
@@ -42,7 +53,7 @@ async function getId (ownerId, dependency) {
 async function getInstanceType (type) {
 
   // TODO: We should be able to use it without {}
-  const types = await product.getAvailableInstances({}).then(sendToApi);
+  const types = await getAvailableInstances({}).then(sendToApi);
 
   const enabledTypes = types.filter((t) => t.enabled);
   const matchingVariants = enabledTypes.filter((t) => t.variant != null && t.variant.slug === type);
@@ -83,21 +94,21 @@ export async function create (name, typeName, region, orgaIdOrName, github, isTa
     newApp.oauthApp = github;
   }
 
-  return application.create({ id: ownerId }, newApp).then(sendToApi);
+  return createApplication({ id: ownerId }, newApp).then(sendToApi);
 };
 
 export async function deleteApp (app, skipConfirmation) {
   Logger.debug('Deleting app: ' + app.name + ' (' + app.id + ')');
 
   if (!skipConfirmation) {
-    await Interact.confirm(
-      `Deleting the application ${app.name} can't be undone, please type '${app.name}' to confirm: `,
+    await confirmAnswer(
+      `Deleting an application can't be undone, please type ${colors.green(app.name)} to confirm:`,
       'No confirmation, aborting application deletion',
-      [app.name],
+      app.name,
     );
   }
 
-  return application.remove({ id: app.ownerId, appId: app.id }).then(sendToApi);
+  return removeApplication({ id: app.ownerId, appId: app.id }).then(sendToApi);
 };
 
 export async function getAllApps (ownerId) {
@@ -123,7 +134,7 @@ export async function getAllApps (ownerId) {
 };
 
 async function getApplicationsForOwner (ownerId) {
-  const rawApplications = await application.getAll({ id: ownerId }).then(sendToApi);
+  const rawApplications = await getAllApplications({ id: ownerId }).then(sendToApi);
   return rawApplications.map((app) => {
     return {
       app_id: app.id,
@@ -150,13 +161,24 @@ function getApplicationByName (apps, name) {
 };
 
 async function getByName (ownerId, name) {
-  const apps = await application.getAll({ id: ownerId }).then(sendToApi);
+  const apps = await getAllApplications({ id: ownerId }).then(sendToApi);
   return getApplicationByName(apps, name);
 };
 
+function addInstanceLifetime (app) {
+  // Patch to help config commands
+  app.instanceLifetime = app.instance.lifetime;
+  return app;
+}
+
 export function get (ownerId, appId) {
   Logger.debug(`Get information for the app: ${appId}`);
-  return application.get({ id: ownerId, appId }).then(sendToApi);
+  return getApplication({ id: ownerId, appId }).then(sendToApi).then(addInstanceLifetime);
+};
+
+export function updateOptions (ownerId, appId, options) {
+  Logger.debug(`Update app: ${appId}`);
+  return updateApplication({ id: ownerId, appId }, options).then(sendToApi).then(addInstanceLifetime);
 };
 
 function getFromSelf (appId) {
@@ -164,7 +186,7 @@ function getFromSelf (appId) {
   // /self differs from /organisations only for this one:
   // it fallbacks to the organisations of which the user
   // is a member, if it doesn't belong to Personal Space.
-  return application.get({ appId }).then(sendToApi);
+  return getApplication({ appId }).then(sendToApi);
 };
 
 /**
@@ -245,7 +267,7 @@ export function unlinkRepo (alias) {
 export function redeploy (ownerId, appId, commit, withoutCache) {
   Logger.debug(`Redeploying the app: ${appId}`);
   const useCache = (withoutCache) ? 'no' : null;
-  return application.redeploy({ id: ownerId, appId, commit, useCache }).then(sendToApi);
+  return redeployApplication({ id: ownerId, appId, commit, useCache }).then(sendToApi);
 };
 
 export function mergeScalabilityParameters (scalabilityParameters, instance) {
@@ -283,7 +305,7 @@ export function mergeScalabilityParameters (scalabilityParameters, instance) {
 export async function setScalability (appId, ownerId, scalabilityParameters, buildFlavor) {
   Logger.info('Scaling the app: ' + appId);
 
-  const app = await application.get({ id: ownerId, appId }).then(sendToApi);
+  const app = await getApplication({ id: ownerId, appId }).then(sendToApi);
   const instance = _.cloneDeep(app.instance);
 
   instance.minFlavor = instance.minFlavor.name;
@@ -301,17 +323,17 @@ export async function setScalability (appId, ownerId, scalabilityParameters, bui
     }
   }
 
-  return application.update({ id: ownerId, appId }, newConfig).then(sendToApi);
+  return updateApplication({ id: ownerId, appId }, newConfig).then(sendToApi);
 };
 
 export async function listDependencies (ownerId, appId, showAll) {
-  const applicationDeps = await application.getAllDependencies({ id: ownerId, appId }).then(sendToApi);
+  const applicationDeps = await getAllDependencies({ id: ownerId, appId }).then(sendToApi);
 
   if (!showAll) {
     return applicationDeps.map((app) => ({ ...app, isLinked: true }));
   }
 
-  const allApps = await application.getAll({ id: ownerId }).then(sendToApi);
+  const allApps = await getAllApplications({ id: ownerId }).then(sendToApi);
 
   const applicationDepsIds = applicationDeps.map((app) => app.id);
   return allApps.map((app) => {
@@ -322,10 +344,10 @@ export async function listDependencies (ownerId, appId, showAll) {
 
 export async function link (ownerId, appId, dependency) {
   const dependencyId = await getId(ownerId, dependency);
-  return application.addDependency({ id: ownerId, appId, dependencyId }).then(sendToApi);
+  return addDependency({ id: ownerId, appId, dependencyId }).then(sendToApi);
 };
 
 export async function unlink (ownerId, appId, dependency) {
   const dependencyId = await getId(ownerId, dependency);
-  return application.removeDependency({ id: ownerId, appId, dependencyId }).then(sendToApi);
+  return removeDependency({ id: ownerId, appId, dependencyId }).then(sendToApi);
 };