@adobe/aio-cli-plugin-api-mesh 1.0.3-beta → 1.1.0

package/src/commands/api-mesh/update.js

@@ -14,24 +14,38 @@ const { readFile } = require('fs/promises');
 
 const logger = require('../../classes/logger');
 const { initSdk, initRequestId, promptConfirm } = require('../../helpers');
+const { ignoreCacheFlag, autoConfirmActionFlag } = require('../../utils');
+const { getMeshId, updateMesh } = require('../../lib/devConsole');
+
+require('dotenv').config();
 
 class UpdateCommand extends Command {
-	static args = [{ name: 'meshId' }, { name: 'file' }];
+	static args = [{ name: 'file' }];
+	static flags = {
+		ignoreCache: ignoreCacheFlag,
+		autoConfirmAction: autoConfirmActionFlag,
+	};
 
 	async run() {
 		await initRequestId();
 
 		logger.info(`RequestId: ${global.requestId}`);
 
-		const { args } = this.parse(UpdateCommand);
+		const { args, flags } = await this.parse(UpdateCommand);
 
-		if (!args.meshId || !args.file) {
+		if (!args.file) {
 			this.error('Missing required args. Run aio api-mesh update --help for more info.');
 
 			return;
 		}
 
-		const { schemaServiceClient, imsOrgId, projectId, workspaceId } = await initSdk();
+		const ignoreCache = await flags.ignoreCache;
+		const autoConfirmAction = await flags.autoConfirmAction;
+
+		const { imsOrgId, projectId, workspaceId } = await initSdk({
+			ignoreCache,
+		});
+
 		let data;
 
 		try {
@@ -45,34 +59,48 @@ class UpdateCommand extends Command {
 			);
 		}
 
-		const shouldContinue = await promptConfirm(
-			`Are you sure you want to update the mesh: ${args.meshId}?`,
-		);
-
-		if (shouldContinue) {
-			try {
-				const response = await schemaServiceClient.updateMesh(
-					imsOrgId,
-					projectId,
-					workspaceId,
-					args.meshId,
-					data,
-				);
+		let meshId = null;
 
-				this.log('Successfully updated the mesh with the id: %s', args.meshId);
+		try {
+			meshId = await getMeshId(imsOrgId, projectId, workspaceId);
+		} catch (err) {
+			this.error(
+				`Unable to get mesh ID. Please check the details and try again. RequestId: ${global.requestId}`,
+			);
+		}
 
-				return response;
-			} catch (error) {
-				this.log(error.message);
+		if (meshId) {
+			let shouldContinue = true;
 
-				this.error(
-					`Unable to update the mesh. Please check the mesh configuration file and try again. If the error persists please contact support. RequestId: ${global.requestId}`,
+			if (!autoConfirmAction) {
+				shouldContinue = await promptConfirm(
+					`Are you sure you want to update the mesh: ${meshId}?`,
 				);
 			}
-		} else {
-			this.log('Update cancelled');
 
-			return 'Update cancelled';
+			if (shouldContinue) {
+				try {
+					const response = await updateMesh(imsOrgId, projectId, workspaceId, meshId, data);
+
+					this.log('Successfully updated the mesh with the id: %s', meshId);
+
+					return response;
+				} catch (error) {
+					this.log(error.message);
+
+					this.error(
+						`Unable to update the mesh. Please check the mesh configuration file and try again. If the error persists please contact support. RequestId: ${global.requestId}`,
+					);
+				}
+			} else {
+				this.log('Update cancelled');
+
+				return 'Update cancelled';
+			}
+		} else {
+			this.error(
+				`Unable to update. No mesh found for Org(${imsOrgId}) -> Project(${projectId}) -> Workspace(${workspaceId}). Please check the details and try again.`,
+			);
 		}
 	}
 }

package/src/constants.js

@@ -0,0 +1,21 @@
+const { getCliEnv } = require('@adobe/aio-lib-env');
+
+const clientEnv = getCliEnv();
+
+const StageConstants = {
+	MULTITENANT_GRAPHQL_SERVER_BASE_URL: 'https://graph-stage.adobe.io/api',
+	DEV_CONSOLE_BASE_URL: 'https://developers-stage.adobe.io/console',
+	DEV_CONSOLE_API_KEY: 'adobe-api-manager-sms-stage',
+	DEV_CONSOLE_TRANSPORTER_API_KEY: 'UDPWeb1',
+	AIO_CLI_API_KEY: 'aio-cli-console-auth-stage',
+};
+
+const ProdConstants = {
+	MULTITENANT_GRAPHQL_SERVER_BASE_URL: 'https://graph.adobe.io/api',
+	DEV_CONSOLE_BASE_URL: 'https://developers.adobe.io/console',
+	DEV_CONSOLE_API_KEY: 'adobe-graph-prod',
+	DEV_CONSOLE_TRANSPORTER_API_KEY: 'UDPWeb1',
+	AIO_CLI_API_KEY: 'aio-cli-console-auth',
+};
+
+module.exports = clientEnv === 'stage' ? StageConstants : ProdConstants;

package/src/helpers.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 /*
 Copyright 2021 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -17,18 +18,13 @@ const { getToken, context } = require('@adobe/aio-lib-ims');
 const { CLI } = require('@adobe/aio-lib-ims/src/context');
 const libConsoleCLI = require('@adobe/aio-cli-lib-console');
 const { getCliEnv } = require('@adobe/aio-lib-env');
-const aioConsoleLogger = require('@adobe/aio-lib-core-logging')('@adobe/aio-cli-plugin-api-mesh', {
-	provider: 'debug',
-});
 
-const { SchemaServiceClient } = require('./classes/SchemaServiceClient');
 const logger = require('../src/classes/logger');
 const { UUID } = require('./classes/UUID');
+const CONSTANTS = require('./constants');
+const { objToString } = require('./utils');
 
-const CONSOLE_API_KEYS = {
-	prod: 'aio-cli-console-auth',
-	stage: 'aio-cli-console-auth-stage',
-};
+const { DEV_CONSOLE_BASE_URL, DEV_CONSOLE_API_KEY, AIO_CLI_API_KEY } = CONSTANTS;
 
 /**
  * @returns {any} Returns a config object or null
@@ -38,9 +34,9 @@ async function getDevConsoleConfig() {
 
 	if (!configFile) {
 		return {
-			baseUrl: 'https://developers.adobe.io/console',
+			baseUrl: DEV_CONSOLE_BASE_URL,
 			accessToken: (await getLibConsoleCLI()).accessToken,
-			apiKey: 'adobe-graph-prod',
+			apiKey: DEV_CONSOLE_API_KEY,
 		};
 	} else {
 		try {
@@ -81,66 +77,191 @@ async function getDevConsoleConfig() {
  * @returns {string} Returns organizations the user belongs to
  */
 async function getAuthorizedOrganization() {
+	logger.info(`Initializing organization selection for`);
+
 	const { consoleCLI } = await getLibConsoleCLI();
 
-	aioConsoleLogger.debug('Get the selected organization');
+	logger.debug('Get the selected organization');
 
 	const consoleConfigOrg = Config.get('console.org');
 
 	if (!consoleConfigOrg) {
 		const organizations = await consoleCLI.getOrganizations();
-		const selectedOrg = await consoleCLI.promptForSelectOrganization(organizations);
 
-		aioConsoleLogger.debug('Set the console config');
+		logger.info(`Retrieved organizations : ${objToString(organizations)}`);
 
-		Config.set('console.org', {
-			id: selectedOrg.id,
-			code: selectedOrg.code,
-			name: selectedOrg.name,
-		});
+		if (organizations.length !== 0) {
+			const selectedOrg = await consoleCLI.promptForSelectOrganization(organizations);
 
-		return Object.assign({}, selectedOrg);
+			logger.debug('Set the console org config');
+
+			Config.set('console.org', selectedOrg);
+
+			// remove selected project and workspace from config and let the user select a new one
+			Config.delete('console.project');
+			Config.delete('console.workspace');
+			return Object.assign({}, selectedOrg);
+		} else {
+			logger.error(`No organizations found`);
+		}
 	} else {
-		logger.info(`Selecting your organization as: ${consoleConfigOrg.name}`);
+		logger.debug(`Selected organization config ${objToString(consoleConfigOrg)}`);
+		console.log(`Selected organization: ${consoleConfigOrg.name}`);
 
 		return Object.assign({}, consoleConfigOrg);
 	}
 }
 
+/**
+ * @param imsOrgId
+ * @param imsOrgTitle
+ */
 async function getProject(imsOrgId, imsOrgTitle) {
 	logger.info(`Initializing project selection for ${imsOrgId}`);
 
 	const { consoleCLI } = await getLibConsoleCLI();
 
-	const projects = await consoleCLI.getProjects(imsOrgId);
-	if (projects.length !== 0) {
-		const selectedProject = await consoleCLI.promptForSelectProject(projects);
+	logger.debug('Get the selected project');
+
+	const consoleConfigProject = Config.get('console.project');
+
+	if (!consoleConfigProject) {
+		const projects = await consoleCLI.getProjects(imsOrgId);
 
-		return selectedProject;
+		logger.debug(`Retrieved projects for ${imsOrgId} : ${objToString(projects)}`);
+
+		if (projects.length !== 0) {
+			const selectedProject = await consoleCLI.promptForSelectProject(projects);
+
+			const shouldCacheProject = await promptConfirm(
+				`Do you want to use ${selectedProject.title} as selected project for future operations?`,
+			);
+
+			if (shouldCacheProject) {
+				Config.set('console.project', selectedProject);
+			}
+
+			// remove selected workspace from config and let the user select a new one
+			Config.delete('console.workspace');
+
+			return Object.assign({}, selectedProject);
+		} else {
+			logger.error(`No projects found for the selected organization: ${imsOrgTitle}`);
+		}
 	} else {
-		aioConsoleLogger.error(`No projects found for the selected organization: ${imsOrgTitle}`);
+		logger.debug(`Selected project config ${objToString(consoleConfigProject)}`);
+		console.log(`Selected project: ${consoleConfigProject.title}`);
+
+		return consoleConfigProject;
 	}
 }
 
+/**
+ * @param orgId
+ * @param projectId
+ * @param imsOrgTitle
+ * @param projectTitle
+ */
 async function getWorkspace(orgId, projectId, imsOrgTitle, projectTitle) {
-	logger.info(`Initializing workspace selection for ${orgId} / ${projectId}`);
+	logger.info(`Initializing workspace selection for ${orgId} -> ${projectId}`);
+
+	const { consoleCLI } = await getLibConsoleCLI();
+
+	logger.debug('Get the selected workspace');
+
+	const consoleConfigWorkspace = Config.get('console.workspace');
+
+	if (!consoleConfigWorkspace) {
+		const workspaces = await consoleCLI.getWorkspaces(orgId, projectId);
+
+		logger.debug(`Retrieved workspaces for ${orgId} -> ${projectId} : ${objToString(workspaces)}`);
+
+		if (workspaces.length !== 0) {
+			const selectedWorkspace = await consoleCLI.promptForSelectWorkspace(workspaces);
+
+			const shouldCacheWorkspace = await promptConfirm(
+				`Do you want to use ${selectedWorkspace.name} as selected workspace for future operations?`,
+			);
+
+			if (shouldCacheWorkspace) {
+				Config.set('console.workspace', selectedWorkspace);
+			}
+
+			return Object.assign({}, selectedWorkspace);
+		} else {
+			logger.error(
+				`No workspaces found for the selected organization: ${imsOrgTitle} and project: ${projectTitle}`,
+			);
+		}
+	} else {
+		logger.debug(`Selected workspace config ${objToString(consoleConfigWorkspace)}`);
+		console.log(`Select workspace: ${consoleConfigWorkspace.name}`);
+
+		return {
+			id: consoleConfigWorkspace.id,
+			title: consoleConfigWorkspace.name,
+		};
+	}
+}
+
+const selectAuthorizedOrganization = async () => {
+	const { consoleCLI } = await getLibConsoleCLI();
+	const organizations = await consoleCLI.getOrganizations();
+
+	if (organizations.length > 0) {
+		const selectedOrg = await consoleCLI.promptForSelectOrganization(organizations);
+
+		if (selectedOrg) {
+			return selectedOrg;
+		} else {
+			throw new Error('No org selected');
+		}
+	} else {
+		this.error('No organizations found');
+	}
+};
 
+const selectProject = async (imsOrgId, imsOrgTitle) => {
 	const { consoleCLI } = await getLibConsoleCLI();
+	const projects = await consoleCLI.getProjects(imsOrgId);
 
+	if (projects.length > 0) {
+		const selectedProject = await consoleCLI.promptForSelectProject(projects);
+
+		if (selectedProject) {
+			return selectedProject;
+		} else {
+			throw new Error('No project selected');
+		}
+	} else {
+		this.error('No projects found for the selected organization: ' + imsOrgTitle);
+	}
+};
+
+const selectWorkspace = async (orgId, projectId, imsOrgTitle, projectTitle) => {
+	const { consoleCLI } = await getLibConsoleCLI();
 	const workspaces = await consoleCLI.getWorkspaces(orgId, projectId);
-	if (workspaces.length !== 0) {
+
+	if (workspaces.length > 0) {
 		const selectedWorkspace = await consoleCLI.promptForSelectWorkspace(workspaces);
 
-		return selectedWorkspace;
+		if (selectedWorkspace) {
+			return selectedWorkspace;
+		} else {
+			throw new Error('No workspace selected');
+		}
 	} else {
-		aioConsoleLogger.error(
-			`No workspaces found for the selected organization: ${imsOrgTitle} and project: ${projectTitle}`,
+		this.error(
+			'No workspaces found for the selected organization: ' +
+				imsOrgTitle +
+				' and project: ' +
+				projectTitle,
 		);
 	}
-}
+};
 
 /**
- * @private
+ * @returns {consoleCLI, accessToken}
  */
 async function getLibConsoleCLI() {
 	await context.setCli({ 'cli.bare-output': true }, false);
@@ -151,7 +272,7 @@ async function getLibConsoleCLI() {
 
 	const consoleCLI = await libConsoleCLI.init({
 		accessToken: accessToken,
-		apiKey: CONSOLE_API_KEYS[clientEnv],
+		apiKey: AIO_CLI_API_KEY,
 		env: clientEnv,
 	});
 
@@ -161,24 +282,30 @@ async function getLibConsoleCLI() {
 /**
  * @returns {any} Returns an object with properties ready for consumption
  */
-async function initSdk() {
-	const org = await getAuthorizedOrganization();
-	const project = await getProject(org.id, org.name);
-	const workspace = await getWorkspace(org.id, project.id, org.name, project.title);
+async function initSdk(options) {
+	const { ignoreCache = false } = options;
 
-	aioConsoleLogger.log(
+	let org;
+	let project;
+	let workspace;
+
+	if (!ignoreCache) {
+		org = await getAuthorizedOrganization();
+		project = await getProject(org.id, org.name);
+		workspace = await getWorkspace(org.id, project.id, org.name, project.title);
+	} else {
+		org = await selectAuthorizedOrganization();
+		project = await selectProject(org.id, org.name);
+		workspace = await selectWorkspace(org.id, project.id, org.name, project.title);
+	}
+
+	logger.info(
 		`Initializing SDK for org: ${org.name}, project: ${project.title} and workspace: ${workspace.title}`,
 	);
 
 	logger.info('Initialized user login and the selected organization');
 
-	const { baseUrl, accessToken, apiKey } = await getDevConsoleConfig();
-
-	const schemaServiceClient = new SchemaServiceClient();
-	schemaServiceClient.init(baseUrl, accessToken, apiKey);
-
 	return {
-		schemaServiceClient: schemaServiceClient,
 		imsOrgId: org.id,
 		projectId: project.id,
 		workspaceId: workspace.id,
@@ -213,10 +340,52 @@ async function promptConfirm(message) {
 	return confirm.res;
 }
 
+/**
+ * Function to run the CLI selectable list
+ *
+ * @param {string} message - prompt message
+ * @param {object[]} choices - list of options
+ * @returns {object[]} - selected options
+ */
+async function promptMultiselect(message, choices) {
+	const selected = await inquirer.prompt([
+		{
+			name: 'items',
+			message: message,
+			type: 'checkbox',
+			choices: choices,
+		},
+	]);
+
+	return selected.items;
+}
+
+/**
+ * Function to run the CLI selectable list
+ *
+ * @param {string} message - prompt message
+ * @param {object[]} choices - list of options
+ * @returns {object[]} - selected options
+ */
+async function promptSelect(message, choices) {
+	const selected = await inquirer.prompt([
+		{
+			name: 'item',
+			message: message,
+			type: 'list',
+			choices: choices,
+		},
+	]);
+
+	return selected.item;
+}
+
 module.exports = {
 	promptConfirm,
 	getLibConsoleCLI,
 	getDevConsoleConfig,
 	initSdk,
 	initRequestId,
+	promptSelect,
+	promptMultiselect,
 };