clever-tools 3.11.0 → 3.12.0

package/src/lib/ng-print.js

@@ -0,0 +1,195 @@
+import colors from 'colors/safe.js';
+import * as networkGroup from '../models/ng.js';
+
+import { Logger } from '../logger.js';
+
+/**
+ * Print a Network Group
+ * @param {Object} ng The Network Group to print
+ * @param {string} format Output format
+ * @param {boolean} full If true, get more details about the Network Group (default: false)
+ */
+function printNg (ng, format, full = false) {
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(ng);
+      break;
+    }
+    case 'human':
+    default: {
+      const ngData = {
+        ID: ng.id,
+        Label: ng.label,
+        Description: ng.description,
+        Network: `${ng.networkIp}`,
+        'Members/Peers': `${Object.keys(ng.members)?.length}/${Object.keys(ng.peers)?.length}`,
+      };
+
+      console.table(ngData);
+
+      if (full) {
+        const members = Object.entries(ng.members)
+          .sort((a, b) => a[1].domainName.localeCompare(b[1].domainName))
+          .map(([id, member]) => ({
+            Domain: member.domainName,
+          }));
+        if (members.length > 0) {
+          Logger.println(colors.bold(' • Members:'));
+          console.table(members);
+        }
+
+        const peers = Object.entries(ng.peers)
+          .sort((a, b) => a[1].parentMember.localeCompare(b[1].parentMember))
+          .map(([id, peer]) => formatPeer(peer));
+        if (peers.length > 0) {
+          Logger.println(colors.bold(' • Peers:'));
+          console.table(peers);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Print a Network Group member
+ * @param {Object} member The Network Group member to print
+ * @param {string} format Output format
+ */
+function printMember (member, format) {
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(member);
+      break;
+    }
+    case 'human':
+    default: {
+      console.table({
+        Label: member.label,
+        Domain: member.domainName,
+      });
+    }
+  }
+}
+
+/**
+ * Print a Network Group peer
+ * @param {Object} peer The Network Group peer to print
+ * @param {string} format Output format
+ * @param {boolean} full If true, get more details about the peer (default: false)
+ */
+function printPeer (peer, format, full = false) {
+  switch (format) {
+    case 'json': {
+      Logger.printJson(peer);
+      break;
+    }
+    case 'human':
+    default: {
+      console.table(formatPeer(peer, full));
+    }
+  }
+}
+
+/**
+ * Format a peer to print
+ * @param {Object} peer
+ * @param {boolean} full If true, get more details about the peer (default: false)
+ */
+function formatPeer (peer, full = false) {
+  const peerToPrint = {
+    'Parent Member': peer.parentMember,
+    ID: peer.id,
+    Label: peer.label,
+    Type: peer.type,
+  };
+
+  if (full) {
+    if (peer.endpoint.ngTerm != null) {
+      peerToPrint['Host:IP'] = `${peer.endpoint.ngTerm.host}:${peer.endpoint.ngTerm.port}`;
+    }
+    else {
+      peerToPrint.Host = peer.endpoint.ngIp;
+    }
+    if (peer.endpoint.publicTerm != null) {
+      peerToPrint['Public Term'] = `${peer.endpoint.publicTerm.host}:${peer.endpoint.publicTerm.port}`;
+    }
+    peerToPrint['Public Key'] = peer.publicKey;
+  }
+
+  return peerToPrint;
+}
+
+/** Print the results of a search or get action
+ * @param {object} idOrLabel ID or label of the Network Group, a member or a peer
+ * @param {object} org Organisation ID or name
+ * @param {string} format Output format
+ * @param {string} action Action to perform (search or get)
+ * @param {string} type Type of item to search (NetworkGroup, Member, Peer)
+ */
+export async function printResults (idOrLabel, org, format, action, type) {
+
+  const exactMatch = action === 'get';
+  const toLookFor = type ?? (action === 'search' ? 'all' : 'single');
+
+  const found = await networkGroup.searchNgOrResource(idOrLabel, org, toLookFor, exactMatch);
+
+  if (!found.length) {
+    const searchString = idOrLabel.ngId
+      ?? idOrLabel.memberId
+      ?? idOrLabel.ngResourceLabel;
+    Logger.println(`${colors.blue('!')} No Network Group or resource found for ${colors.blue(searchString)}`);
+    return;
+  }
+
+  if (found.length === 1) {
+    switch (found[0].type) {
+      case 'NetworkGroup':
+        return printNg(found[0], format, true);
+      case 'Member':
+        return printMember(found[0], format);
+      case 'CleverPeer':
+      case 'ExternalPeer':
+        return printPeer(found[0], format, true);
+      default:
+        throw new Error(`Unknown item type: ${found[0].type}`);
+    }
+  }
+
+  if (action === 'search') {
+    // Group found items by type in a new object
+    const grouped = found.reduce((acc, item) => {
+      if (!acc[item.type]) {
+        acc[item.type] = [];
+      }
+      acc[item.type].push(item);
+      return acc;
+    }, {});
+
+    switch (format) {
+      case 'json': {
+        Logger.printJson(grouped);
+        break;
+      }
+      case 'human':
+      default: {
+        if (grouped.NetworkGroup) {
+          Logger.println(`${colors.bold(` • Found ${grouped.NetworkGroup.length} Network Group(s):`)}`);
+          grouped.NetworkGroup?.forEach((item) => printNg(item, format));
+        }
+
+        if (grouped.Member) {
+          Logger.println(`${colors.bold(` • Found ${grouped.Member.length} Member(s):`)}`);
+          grouped.Member?.forEach((item) => printMember(item, format));
+        }
+
+        if (grouped.ExternalPeer || grouped.CleverPeer) {
+          Logger.println(`${colors.bold(` • Found ${grouped.ExternalPeer.length + grouped.CleverPeer.length} Peer(s):`)}`);
+          grouped.CleverPeer?.forEach((item) => printPeer(item, format));
+          grouped.ExternalPeer?.forEach((item) => printPeer(item, format));
+        }
+      }
+    }
+  }
+}

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';
@@ -10,6 +9,7 @@ import * as Interact from './interact.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,12 +191,12 @@ 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) {

package/src/models/application.js

@@ -1,7 +1,16 @@
 import _ from 'lodash';
-import * as application from '@clevercloud/client/esm/api/v2/application.js';
+import {
+  create as createApplication,
+  remove as removeApplication,
+  getAll as getAllApplications,
+  get as getApplication,
+  redeploy as redeployApplication,
+  update as updateApplication,
+  getAllDependencies,
+  addDependency,
+  removeDependency,
+} 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 * as AppConfiguration from './app_configuration.js';
@@ -12,6 +21,7 @@ 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']);
@@ -42,7 +52,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,7 +93,7 @@ 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) {
@@ -97,7 +107,7 @@ export async function deleteApp (app, skipConfirmation) {
     );
   }
 
-  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 +133,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 +160,13 @@ 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);
 };
 
 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);
 };
 
 function getFromSelf (appId) {
@@ -164,7 +174,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 +255,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 +293,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 +311,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 +332,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);
 };

package/src/models/configuration.js

@@ -123,6 +123,7 @@ export async function setFeature (feature, value) {
 
 export const conf = env.getOrElseAll({
   API_HOST: 'https://api.clever-cloud.com',
+  AUTH_BRIDGE_HOST: 'https://api-bridge.clever-cloud.com',
   SSH_GATEWAY: 'ssh@sshgateway-clevercloud-customers.services.clever-cloud.com',
 
   // the disclosure of these tokens is not considered as a vulnerability. Do not report this to our security service.

package/src/models/namespaces.js

@@ -1,9 +1,10 @@
 import * as Application from './application.js';
-import * as organisation from '@clevercloud/client/esm/api/v2/organisation.js';
+import { getNamespaces as getTcpRedirNamespaces } from '@clevercloud/client/esm/api/v2/organisation.js';
 import { sendToApi } from './send-to-api.js';
 import cliparse from 'cliparse';
+
 export async function getNamespaces (ownerId) {
-  return organisation.getNamespaces({ id: ownerId }).then(sendToApi);
+  return getTcpRedirNamespaces({ id: ownerId }).then(sendToApi);
 }
 
 export async function completeNamespaces () {

package/src/models/ng-resources.js

@@ -0,0 +1,270 @@
+import colors from 'colors/safe.js';
+import * as networkGroup from './ng.js';
+import * as networkGroupApi from '@clevercloud/client/esm/api/v4/network-group.js';
+
+import crypto from 'node:crypto';
+import { setTimeout } from 'node:timers/promises';
+import { Logger } from '../logger.js';
+import { sendToApi } from './send-to-api.js';
+import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
+
+/**
+ * Create an external peer and link its parent member to the Network Group
+ * @param {object} ngIdOrLabel The Network Group ID or Label
+ * @param {string} peerLabel External peer label
+ * @param {string} publicKey External peer public key
+ * @param {object} org Organisation ID or name
+ * @throws {Error} If a valid peer label is not provided
+ * @throws {Error} If the Network Group is not found
+ * @throws {Error} If the parent member is not linked to the Network Group
+ * @throws {Error} If the external peer is not linked to the Network Group
+ */
+export async function createExternalPeerWithParent (ngIdOrLabel, peerLabel, publicKey, org) {
+
+  if (!peerLabel) {
+    throw new Error('A valid peer label is required');
+  }
+
+  const [ng] = await networkGroup.searchNgOrResource(ngIdOrLabel, org, 'NetworkGroup');
+
+  if (!ng) {
+    throw new Error(`Network Group ${colors.red(ngIdOrLabel.ngId || ngIdOrLabel.ngResourceLabel)} not found`);
+  }
+
+  // We define a parent member for the external peer
+  const id = `external_${crypto.randomUUID()}`;
+  const parentMember = {
+    id,
+    label: `Parent of ${peerLabel}`,
+    domainName: `${id}.m.${ng.id}.${networkGroup.DOMAIN}`,
+    kind: 'EXTERNAL',
+  };
+
+  Logger.info(`Creating a parent member ${parentMember.id} linked to Network Group ${ng.id}`);
+  await linkMember({ ngId: ng.id }, parentMember.id, org, parentMember.label);
+
+  const checkParentMember = await checkResource(ng.id, org, parentMember.id, true);
+  if (!checkParentMember) {
+    throw new Error(`Parent member ${colors.red(parentMember.id)} not linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`Parent member ${parentMember.id} created and linked to Network Group ${ng.id}`);
+
+  // We define the external peer, for now we only support client role
+  const body = {
+    peerRole: 'CLIENT',
+    publicKey,
+    label: peerLabel,
+    parentMember: parentMember.id,
+  };
+
+  Logger.info(`Adding external peer to Member ${parentMember.id} of Network Group ${ng.id}`);
+  Logger.debug('Sending body: ' + JSON.stringify(body, null, 2));
+  await networkGroupApi.createNetworkGroupExternalPeer({ ownerId: ng.ownerId, networkGroupId: ng.id }, body).then(sendToApi);
+
+  const checkExternalPeer = await checkResource(ng.id, org, peerLabel, true, 'peer', 'label');
+  if (!checkExternalPeer) {
+    throw new Error(`External peer ${colors.red(peerLabel)} not linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`External peer ${peerLabel} added to Member ${parentMember.id} of Network Group ${ng.id}`);
+}
+
+/**
+ * Delete an external peer and its parent member from a Network Group
+ * @param {object} ngIdOrLabel Network Group ID or label
+ * @param {string} peerIdOrLabel External peer ID or label
+ * @param {object} org Organisation ID or name
+ * @throws {Error} If the Network Group is not found
+ * @throws {Error} If the External Peer is not found
+ * @throws {Error} If the External Peer is still linked to the Network Group
+ * @throws {Error} If the Parent Member is still linked to the Network Group
+ */
+export async function deleteExternalPeerWithParent (ngIdOrLabel, peerIdOrLabel, org) {
+
+  const [ng] = await networkGroup.searchNgOrResource(ngIdOrLabel, org, 'NetworkGroup');
+
+  if (!ng) {
+    throw new Error(`Network Group ${colors.red(ngIdOrLabel.ngId || ngIdOrLabel.ngResourceLabel)} not found`);
+  }
+
+  const externalPeer = ng.peers.find((p) => {
+    return p.id === peerIdOrLabel || p.label === peerIdOrLabel;
+  });
+
+  if (!externalPeer) {
+    throw new Error(`External peer ${colors.red(peerIdOrLabel)} not found`);
+  }
+
+  Logger.info(`Deleting external peer ${externalPeer.id} from Network Group ${ng.id}`);
+  await networkGroupApi.deleteNetworkGroupExternalPeer({ ownerId: ng.ownerId, networkGroupId: ng.id, peerId: externalPeer.id }).then(sendToApi);
+
+  const checkPeer = await checkResource(ng.id, org, externalPeer.id, false, 'peer');
+  if (!checkPeer) {
+    throw new Error(`External peer ${colors.red(externalPeer.id)} still linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`External peer ${externalPeer.id} deleted from Network Group ${ng.id}`);
+  Logger.info(`Unlinking parent member ${externalPeer.parentMember} from Network Group ${ng.id}`);
+
+  await unlinkMember(ngIdOrLabel, externalPeer.parentMember, org);
+
+  const checkParentMember = await checkResource(ng.id, org, externalPeer.parentMember, false);
+  if (!checkParentMember) {
+    throw new Error(`Parent member ${colors.red(externalPeer.parentMember)} still linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`Parent member ${externalPeer.parentMember} unlinked from Network Group ${ng.id}`);
+}
+
+/**
+ * Link a Member to a Network Group
+ * @param {object} ngIdOrLabel The Network group ID or Label
+ * @param {string} memberId ID of the Member to link
+ * @param {object} org Organisation ID or name
+ * @param {string} label Label of the Member
+ */
+export async function linkMember (ngIdOrLabel, memberId, org, label) {
+  if (!memberId) {
+    throw new Error('A valid member ID is required (addon_xxx, app_xxx, external_xxx)');
+  }
+
+  const [ng] = await networkGroup.searchNgOrResource(ngIdOrLabel, org, 'NetworkGroup');
+
+  if (!ng) {
+    throw new Error(`Network Group ${colors.red(ngIdOrLabel.ngId || ngIdOrLabel.ngResourceLabel)} not found`);
+  }
+
+  await checkMembersToLink([memberId], ng.ownerId);
+
+  const alreadyMember = ng.members.find((m) => m.id === memberId);
+  if (alreadyMember) {
+    throw new Error(`Member ${colors.red(memberId)} is already linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  const [member] = networkGroup.constructMembers(ng.id, [memberId]);
+
+  const body = {
+    id: member.id,
+    label: label || member.label,
+    domainName: member.domainName,
+    kind: member.kind,
+  };
+
+  Logger.info(`Linking member ${member.id} to Network Group ${ng.id}`);
+  Logger.debug('Sending body: ' + JSON.stringify(body, null, 2));
+  await networkGroupApi.createNetworkGroupMember({ ownerId: ng.ownerId, networkGroupId: ng.id }, body).then(sendToApi);
+
+  const check = await checkResource(ng.id, org, member.id, true);
+  if (!check) {
+    throw new Error(`Member ${colors.red(member.id)} not linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`Member ${member.id} linked to Network Group ${ng.id}`);
+}
+
+/**
+ * Unlink a Member from a Network Group
+ * @param {object} ngIdOrLabel The Network Group ID or Label
+ * @param {string} memberId The Member ID
+ * @param {object} org Organisation ID or name
+ * @throws {Error} If a valid member ID is not provided
+ * @throws {Error} If the Network Group is not found
+ * @throws {Error} If the Member is not found in the Network Group
+ * @throws {Error} If the Member is still linked to the Network Group
+ */
+export async function unlinkMember (ngIdOrLabel, memberId, org) {
+  if (!memberId) {
+    throw new Error('A valid member ID is required (addon_xxx, app_xxx, external_xxx)');
+  }
+
+  const [ng] = await networkGroup.searchNgOrResource(ngIdOrLabel, org, 'NetworkGroup');
+
+  if (!ng) {
+    throw new Error(`Network Group ${colors.red(ngIdOrLabel.ngId || ngIdOrLabel.ngLabel)} not found`);
+  }
+
+  const member = ng.members.find((m) => m.id === memberId);
+  if (!member) {
+    throw new Error(`Member ${colors.red(memberId)} not found in Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`Unlinking member ${memberId} from Network Group ${ng.id}`);
+  await networkGroupApi.deleteNetworkGroupMember({ ownerId: ng.ownerId, networkGroupId: ng.id, memberId }).then(sendToApi);
+
+  const check = await checkResource(ng.id, org, memberId, false);
+  if (!check) {
+    throw new Error(`Member ${colors.red(memberId)} still linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`Member ${memberId} unlinked from Network Group ${ng.id}`);
+}
+
+/**
+ * Check if members can be linked to a Network Group
+ * @param {Array<string>} members Members to check
+ * @throws {Error} If members can't be linked to a Network Group
+ */
+export async function checkMembersToLink (members, ownerId) {
+  const VALID_ADDON_PROVIDERS = [
+    'es-addon',
+    'mongodb-addon',
+    'mysql-addon',
+    'postgresql-addon',
+    'redis-addon',
+  ];
+
+  const summary = await getSummary().then(sendToApi);
+
+  let data = summary.user;
+  if (summary.user.id !== ownerId) {
+    data = summary.organisations.find((o) => o.id === ownerId);
+  }
+
+  const membersNotOK = [];
+  let source = data.applications;
+
+  for (const memberId of members) {
+    if (memberId.startsWith('addon_')) source = data.addons;
+
+    const foundRessource = source.find((r) => r.id === memberId);
+
+    if (foundRessource && memberId.startsWith('addon_') && !VALID_ADDON_PROVIDERS.includes(foundRessource.providerId)) {
+      membersNotOK.push(memberId);
+    }
+    else if (!foundRessource && !memberId.startsWith('external_')) {
+      membersNotOK.push(memberId);
+    }
+  }
+
+  if (membersNotOK.length > 0) {
+    throw new Error(`Member(s) ${colors.red(membersNotOK.join(', '))} can't be linked to the Network Group, check Organisation ID or name`);
+  }
+}
+
+/**
+ * Check if a resource is present in a Network Group by ID or label
+ * @param {string} ngId Network Group ID
+ * @param {object} org Organisation ID or name
+ * @param {string} resource Resource ID or label
+ * @param {boolean} shouldBePresent Expected presence of the resource
+ * @param {string} [resourceType] Resource type (member or peer), default is member
+ * @param {string} [searchBy] Search by 'id' or 'label', default is 'id'
+ * @returns {Promise<boolean>} True if the resource is present, false otherwise
+ */
+async function checkResource (ngId, org, resource, shouldBePresent, resourceType = 'member', searchBy = 'id') {
+  const endTime = Date.now() + networkGroup.POLLING_TIMEOUT_MS;
+
+  while (Date.now() < endTime) {
+    const ng = await networkGroup.getNG(ngId, org);
+    const items = resourceType === 'member' ? ng.members : ng.peers;
+    const isPresent = items.some((item) => item[searchBy] === resource);
+
+    if (isPresent === shouldBePresent) {
+      return true;
+    }
+
+    await setTimeout(networkGroup.POLLING_INTERVAL_MS);
+  }
+  return false;
+}