clever-tools 4.7.0 → 4.8.0

package/src/lib/zod-utils.js

@@ -1,6 +1,7 @@
 /**
  * @typedef {Object} ZodSchemaLike
  * @property {{ type?: string, innerType?: ZodSchemaLike, defaultValue?: unknown, typeName?: string, in?: ZodSchemaLike }} [_def]
+ * @property {string[]} [options]
  */
 
 /**
@@ -37,6 +38,56 @@ export function isRequired(schema) {
   return true;
 }
 
+/**
+ * Extracts enum values from a Zod schema.
+ * Handles wrapped schemas (default, optional, nullable, pipe).
+ * @param {ZodSchemaLike} schema
+ * @return {string[] | null}
+ */
+export function getEnumValues(schema) {
+  /** @type {ZodSchemaLike | undefined} */
+  let current = schema;
+  while (current) {
+    const schemaType = current._def?.type;
+    if (schemaType === 'enum') {
+      return current.options ?? null;
+    }
+    if (schemaType === 'default' || schemaType === 'optional' || schemaType === 'nullable') {
+      current = current._def?.innerType;
+      continue;
+    }
+    if (schemaType === 'pipe') {
+      current = current._def?.in;
+      continue;
+    }
+    break;
+  }
+  return null;
+}
+
+/**
+ * Unwraps optional/nullable/default/pipe wrappers to get the inner schema.
+ * @param {ZodSchemaLike} schema
+ * @return {ZodSchemaLike}
+ */
+export function unwrapSchema(schema) {
+  /** @type {ZodSchemaLike | undefined} */
+  let current = schema;
+  while (current) {
+    const schemaType = current._def?.type;
+    if (schemaType === 'optional' || schemaType === 'nullable' || schemaType === 'default') {
+      current = current._def?.innerType;
+      continue;
+    }
+    if (schemaType === 'pipe') {
+      current = current._def?.in;
+      continue;
+    }
+    break;
+  }
+  return /** @type {ZodSchemaLike} */ (current);
+}
+
 /**
  * Extracts the default value from a Zod schema.
  * Handles wrapped schemas (optional, nullable, pipe).

package/src/models/drain.js

@@ -1,3 +1,20 @@
+import * as Application from './application.js';
+import { resolveAddon } from './ids-resolver.js';
+
+export async function resolveDrainResource(alias, appIdOrName, addonIdOrRealId) {
+  if (addonIdOrRealId != null && (appIdOrName != null || alias != null)) {
+    throw new Error('`--addon` cannot be combined with `--app` or `--alias`');
+  }
+
+  if (addonIdOrRealId != null) {
+    const { ownerId, realId } = await resolveAddon(addonIdOrRealId);
+    return { ownerId, resourceId: realId };
+  }
+
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+  return { ownerId, resourceId: appId };
+}
+
 export const DRAIN_TYPES = {
   DATADOG: { apiCode: 'DATADOG', cliCode: 'datadog', label: 'Datadog' },
   ELASTICSEARCH: { apiCode: 'ELASTICSEARCH', cliCode: 'elasticsearch', label: 'Elasticsearch' },

package/src/models/ids-resolver.js

@@ -31,28 +31,17 @@ export async function resolveOwnerId(id) {
   return getIdFromCacheOrSummary((ids) => ids.owners[id]);
 }
 
-export async function resolveAddonId(id) {
-  const addonId = await getIdFromCacheOrSummary((ids) => {
-    return ids.addons[id] != null ? ids.addons[id].addonId : null;
+export async function resolveAddon(addonIdOrRealId) {
+  const result = await getIdFromCacheOrSummary((ids) => {
+    const addon = ids.addons[addonIdOrRealId];
+    if (addon == null) return null;
+    const ownerId = ids.owners[addon.realId];
+    return { ownerId, addonId: addon.addonId, realId: addon.realId };
   });
-
-  if (addonId != null) {
-    return addonId;
-  }
-
-  throw new Error(`Add-on ${id} does not exist`);
-}
-
-export async function resolveRealId(id) {
-  const realId = await getIdFromCacheOrSummary((ids) => {
-    return ids.addons[id] != null ? ids.addons[id].realId : null;
-  });
-
-  if (realId != null) {
-    return realId;
+  if (result == null) {
+    throw new Error(`Add-on ${addonIdOrRealId} does not exist`);
   }
-
-  throw new Error(`Add-on ${id} does not exist foo`);
+  return result;
 }
 
 async function getIdFromCacheOrSummary(callback) {
@@ -94,6 +83,9 @@ async function getIdsFromSummary() {
       ids.addons[addon.id] = addonIds;
       ids.addons[addon.realId] = addonIds;
     }
+    for (const consumer of owner.consumers) {
+      ids.owners[consumer.key] = owner.id;
+    }
   }
 
   return ids;
@@ -174,6 +166,32 @@ export async function findAddonsByAddonProvider(provider) {
   return candidates;
 }
 
+/**
+ * Find OAuth consumers by key or name.
+ * Fast path: tries the IDs cache first (works for keys).
+ * Fallback: fetches the summary and searches by key or name.
+ * @param {string} keyOrName
+ * @returns {Promise<Array<{ ownerId: string, key: string, name: string }>>}
+ */
+export async function findOauthConsumersByKeyOrName(keyOrName) {
+  const ownerIdFromCache = await resolveOwnerId(keyOrName);
+  if (ownerIdFromCache != null) {
+    return [{ ownerId: ownerIdFromCache, key: keyOrName }];
+  }
+
+  const summary = await getSummary().then(sendToApi);
+  const consumers = [summary.user, ...summary.organisations].flatMap((owner) => {
+    return owner.consumers.map((c) => ({ ownerId: owner.id, name: c.name, key: c.key }));
+  });
+
+  const matchByKey = consumers.find((c) => c.key === keyOrName);
+  if (matchByKey) {
+    return [matchByKey];
+  }
+
+  return consumers.filter((c) => c.name === keyOrName);
+}
+
 /**
  * Get the owner ID from an Organisation ID or name
  * @param {object} orgIdOrName The Organisation ID or name

package/src/models/ng.js

@@ -79,7 +79,7 @@ export async function destroy(ngIdOrLabel, orgaIdOrName) {
  * @param {object} peerIdOrLabel The Peer ID or Label
  * @param {object} ngIdOrLabel The Network Group ID or Label
  * @param {object} orgaIdOrName The owner ID or name
- * @returns {Promise<Object>} The Peer WireGuard configuration
+ * @returns {Promise<string>} The Peer WireGuard configuration
  * @throws {Error} If the Peer is not found
  * @throws {Error} If the Network Group is not found
  * @throws {Error} If the Peer is not in the Network Group
@@ -113,7 +113,7 @@ export async function getPeerConfig(peerIdOrLabel, ngIdOrLabel, orgaIdOrName) {
     networkGroupId: parentNg.id,
     peerId: peer.id,
   }).then(sendToApi);
-  Logger.debug(`Received from API:\n${JSON.stringify(result, null, 2)}`);
+  Logger.debug(`Received from API:\n${result}`);
 
   return result;
 }

package/src/models/notification.js

@@ -6,10 +6,6 @@ export function listMetaEvents() {
   return ['META_SERVICE_LIFECYCLE', 'META_DEPLOYMENT_RESULT', 'META_SERVICE_MANAGEMENT', 'META_CREDITS'];
 }
 
-export function getOrgaIdOrUserId(orgIdOrName) {
-  return orgIdOrName == null ? User.getCurrentId() : Organisation.getId(orgIdOrName);
-}
-
 export async function getOwnerAndApp(org, useLinkedApp) {
   if (org != null) {
     return { ownerId: await Organisation.getId(org) };

package/src/models/oauth-consumer.js

@@ -0,0 +1,77 @@
+import { get as getOauthConsumer } from '@clevercloud/client/esm/api/v2/oauth-consumer.js';
+import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
+import { promptCheckbox } from '../lib/prompts.js';
+import { styleText } from '../lib/style-text.js';
+import { findOauthConsumersByKeyOrName } from './ids-resolver.js';
+import { sendToApi } from './send-to-api.js';
+
+/* eslint-disable camelcase */
+export const OAUTH_RIGHTS = {
+  access_organisations: 'access-organisations',
+  access_organisations_bills: 'access-organisations-bills',
+  access_organisations_consumption_statistics: 'access-organisations-consumption-statistics',
+  access_organisations_credit_count: 'access-organisations-credit-count',
+  access_personal_information: 'access-personal-information',
+  manage_organisations: 'manage-organisations',
+  manage_organisations_applications: 'manage-organisations-applications',
+  manage_organisations_members: 'manage-organisations-members',
+  manage_organisations_services: 'manage-organisations-services',
+  manage_personal_information: 'manage-personal-information',
+  manage_ssh_keys: 'manage-ssh-keys',
+};
+/* eslint-enable camelcase */
+
+export function rightsFromList(requestedRights = []) {
+  const hasAll = requestedRights.includes('all');
+  return Object.fromEntries(
+    Object.entries(OAUTH_RIGHTS).map(([apiName, cliName]) => {
+      return [apiName, hasAll || requestedRights.includes(cliName)];
+    }),
+  );
+}
+
+const READONLY_RIGHTS = ['almighty'];
+
+export function removeReadonlyRights(rights) {
+  return Object.fromEntries(
+    Object.entries(rights).filter(([key]) => {
+      return !READONLY_RIGHTS.includes(key);
+    }),
+  );
+}
+
+export async function promptRights(existingRights) {
+  const choices = Object.entries(OAUTH_RIGHTS).map(([apiName, cliName]) => ({
+    name: cliName,
+    value: cliName,
+    checked: existingRights?.[apiName] ?? false,
+  }));
+
+  const selected = await promptCheckbox('Select rights', choices);
+
+  return rightsFromList(selected);
+}
+
+export async function getAllConsumers() {
+  const summary = await getSummary().then(sendToApi);
+  return [summary.user, ...summary.organisations].flatMap((owner) => {
+    return owner.consumers.map((c) => ({ ownerId: owner.id, ownerName: owner.name, ...c }));
+  });
+}
+
+export async function resolveOauthConsumer(keyOrName) {
+  const candidates = await findOauthConsumersByKeyOrName(keyOrName);
+
+  if (candidates.length === 0) {
+    throw new Error(`OAuth consumer not found: ${styleText('red', keyOrName)}`);
+  }
+
+  if (candidates.length > 1) {
+    const list = candidates.map((c) => `  - ${c.name} ${styleText('grey', `(${c.key})`)}`).join('\n');
+    throw new Error(`Ambiguous name ${styleText('red', keyOrName)}, use the key instead:\n${list}`);
+  }
+
+  const { ownerId, key } = candidates[0];
+  const oauthConsumer = await getOauthConsumer({ id: ownerId, key }).then(sendToApi);
+  return { ownerId, ...oauthConsumer };
+}

package/src/models/utils.js

@@ -26,7 +26,7 @@ export function openBrowser(urlOrPath, message) {
   const url = urlOrPath.startsWith('/') ? `${config.CONSOLE_URL}${urlOrPath}` : urlOrPath;
 
   Logger.debug(`Opening URL "${url}" in browser`);
-  Logger.println(message);
+  Logger.println(`🌐 ${message}`);
 
   return openPage(url, { wait: false });
 }