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

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

@@ -10,104 +10,280 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-const inquirer = require('inquirer');
+jest.mock('axios');
+jest.mock('fs/promises');
+jest.mock('@adobe/aio-lib-env');
+jest.mock('../../../helpers', () => ({
+	initSdk: jest.fn().mockResolvedValue({}),
+	initRequestId: jest.fn().mockResolvedValue({}),
+	promptConfirm: jest.fn().mockResolvedValue(true),
+}));
+jest.mock('@adobe/aio-cli-lib-console', () => ({
+	init: jest.fn().mockResolvedValue(mockConsoleCLIInstance),
+	cleanStdOut: jest.fn(),
+}));
+jest.mock('@adobe/aio-lib-ims');
+jest.mock('../../../lib/devConsole');
 
 const mockConsoleCLIInstance = {};
-jest.mock('@adobe/aio-lib-env');
-const orgs = [{ id: '1234', code: 'CODE1234@AdobeOrg', name: 'ORG01', type: 'entp' }];
-const selectedOrg = { id: '1234', code: 'CODE1234@AdobeOrg', name: 'ORG01', type: 'entp' };
 
-const projects = [{ id: '5678', title: 'Project01' }];
+const selectedOrg = { id: '1234', code: 'CODE1234@AdobeOrg', name: 'ORG01', type: 'entp' };
 const selectedProject = { id: '5678', title: 'Project01' };
-
-const workspaces = [{ id: '123456789', title: 'Workspace01' }];
 const selectedWorkspace = { id: '123456789', title: 'Workspace01' };
 
-function setDefaultMockConsoleCLI() {
-	mockConsoleCLIInstance.getToken = jest.fn().mockReturnValue('test_token');
-	mockConsoleCLIInstance.getCliEnv = jest.fn().mockReturnValue('prod');
+const { readFile } = require('fs/promises');
 
-	mockConsoleCLIInstance.getOrganizations = jest.fn().mockResolvedValue(orgs);
-	mockConsoleCLIInstance.promptForSelectOrganization = jest.fn().mockResolvedValue(selectedOrg);
-
-	mockConsoleCLIInstance.getProjects = jest.fn().mockResolvedValue(projects);
-	mockConsoleCLIInstance.promptForSelectProject = jest.fn().mockResolvedValue(selectedProject);
-
-	mockConsoleCLIInstance.getWorkspaces = jest.fn().mockResolvedValue(workspaces);
-	mockConsoleCLIInstance.promptForSelectWorkspace = jest.fn().mockResolvedValue(selectedWorkspace);
-}
+const UpdateCommand = require('../update');
+const { initSdk, initRequestId, promptConfirm } = require('../../../helpers');
+const { getMeshId, updateMesh } = require('../../../lib/devConsole');
 
-jest.mock('inquirer', () => ({
-	createPromptModule: jest.fn().mockReturnValue(
-		jest.fn().mockResolvedValue({
-			res: true,
-		}),
-	),
-}));
+let logSpy = null;
+let errorLogSpy = null;
 
-jest.mock('@adobe/aio-cli-lib-console', () => ({
-	init: jest.fn().mockResolvedValue(mockConsoleCLIInstance),
-	cleanStdOut: jest.fn(),
-}));
-jest.mock('@adobe/aio-lib-ims');
+let parseSpy = null;
 
-const UpdateCommand = require('../update');
-const { SchemaServiceClient } = require('../../../classes/SchemaServiceClient');
-const mockUpdateMesh = require('../../__fixtures__/sample_mesh.json');
+const mockIgnoreCacheFlag = Promise.resolve(true);
+const mockAutoApproveAction = Promise.resolve(false);
 
 describe('update command tests', () => {
 	beforeEach(() => {
-		setDefaultMockConsoleCLI();
-		const response = mockUpdateMesh;
-		jest.spyOn(SchemaServiceClient.prototype, 'updateMesh').mockImplementation(data => response);
+		initSdk.mockResolvedValue({
+			imsOrgId: selectedOrg.id,
+			projectId: selectedProject.id,
+			workspaceId: selectedWorkspace.id,
+		});
+
+		global.requestId = 'dummy_request_id';
+
+		logSpy = jest.spyOn(UpdateCommand.prototype, 'log');
+		errorLogSpy = jest.spyOn(UpdateCommand.prototype, 'error');
+
+		readFile.mockResolvedValue(true);
+
+		getMeshId.mockResolvedValue('mesh_id');
+		updateMesh.mockResolvedValue({ status: 'success' });
+
+		parseSpy = jest.spyOn(UpdateCommand.prototype, 'parse');
+		parseSpy.mockResolvedValue({
+			args: { file: 'valid_file_path' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
 	});
 
 	afterEach(() => {
 		jest.restoreAllMocks();
 	});
 
+	test('should fail if mesh id is missing', async () => {
+		getMeshId.mockResolvedValue(null);
+		const runResult = UpdateCommand.run();
+
+		await expect(runResult).rejects.toMatchInlineSnapshot(
+			`[Error: Unable to update. No mesh found for Org(1234) -> Project(5678) -> Workspace(123456789). Please check the details and try again.]`,
+		);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Unable to update. No mesh found for Org(1234) -> Project(5678) -> Workspace(123456789). Please check the details and try again.",
+		  ],
+		]
+	`);
+	});
+
+	test('should fail if getMeshId api failed', async () => {
+		getMeshId.mockRejectedValue(new Error('getMeshId api failed'));
+		const runResult = UpdateCommand.run();
+
+		await expect(runResult).rejects.toMatchInlineSnapshot(
+			`[Error: Unable to get mesh ID. Please check the details and try again. RequestId: dummy_request_id]`,
+		);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Unable to get mesh ID. Please check the details and try again. RequestId: dummy_request_id",
+		  ],
+		]
+	`);
+	});
+
 	test('should fail if update file path is missing', async () => {
-		expect.assertions(2);
-		const runResult = UpdateCommand.run(['dummy_mesh_id']);
-		await expect(runResult instanceof Promise).toBeTruthy();
+		parseSpy.mockResolvedValueOnce({
+			args: { file: null },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+		const runResult = UpdateCommand.run();
+
 		await expect(runResult).rejects.toEqual(
 			new Error('Missing required args. Run aio api-mesh update --help for more info.'),
 		);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Missing required args. Run aio api-mesh update --help for more info.",
+		  ],
+		]
+	`);
 	});
 
 	test('should fail if dummy file path is provided', async () => {
-		expect.assertions(2);
-		const runResult = UpdateCommand.run(['dummy_mesh_id', 'dummy_file_path']);
-		await expect(runResult instanceof Promise).toBeTruthy();
+		readFile.mockRejectedValueOnce(new Error('File not found'));
+		const runResult = UpdateCommand.run();
+
 		await expect(runResult).rejects.toEqual(
 			new Error(
 				'Unable to read the mesh configuration file provided. Please check the file and try again.',
 			),
 		);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "File not found",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Unable to read the mesh configuration file provided. Please check the file and try again.",
+		  ],
+		]
+	`);
 	});
 
-	test('should pass with valid args', async () => {
-		expect.assertions(2);
-		const runResult = UpdateCommand.run([
-			'sample_merchant',
-			'src/commands/__fixtures__/sample_mesh.json',
-		]);
-		await expect(runResult instanceof Promise).toBeTruthy();
-		await expect(runResult).resolves.toEqual(mockUpdateMesh);
+	test('should not update if user prompt returns false', async () => {
+		promptConfirm.mockResolvedValueOnce(false);
+
+		const runResult = await UpdateCommand.run();
+
+		expect(runResult).toMatchInlineSnapshot(`"Update cancelled"`);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Update cancelled",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
 	});
 
-	test('should not update if user prompt returns false', async () => {
-		inquirer.createPromptModule.mockReturnValue(
-			jest.fn().mockResolvedValue({
-				res: false,
-			}),
+	test('should fail if updateMesh method failed', async () => {
+		updateMesh.mockRejectedValueOnce(new Error('dummy_error'));
+
+		const runResult = UpdateCommand.run();
+
+		await expect(runResult).rejects.toEqual(
+			new Error(
+				'Unable to update the mesh. Please check the mesh configuration file and try again. If the error persists please contact support. RequestId: dummy_request_id',
+			),
 		);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "dummy_error",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Unable to update the mesh. Please check the mesh configuration file and try again. If the error persists please contact support. RequestId: dummy_request_id",
+		  ],
+		]
+	`);
+	});
+
+	test('should pass with valid args', async () => {
+		const runResult = await UpdateCommand.run();
+
+		expect(runResult).toMatchInlineSnapshot(`
+		Object {
+		  "status": "success",
+		}
+	`);
+		expect(initRequestId).toHaveBeenCalled();
+		expect(initSdk).toHaveBeenCalledWith({
+			ignoreCache: true,
+		});
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Successfully updated the mesh with the id: %s",
+		    "mesh_id",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+	});
+
+	test('should pass with valid args and ignoreCache flag', async () => {
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'valid_file_name' },
+			flags: {
+				ignoreCache: Promise.resolve(true),
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
+		const runResult = await UpdateCommand.run();
+
+		expect(runResult).toMatchInlineSnapshot(`
+		Object {
+		  "status": "success",
+		}
+	`);
+		expect(initRequestId).toHaveBeenCalled();
+		expect(initSdk).toHaveBeenCalledWith({
+			ignoreCache: true,
+		});
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Successfully updated the mesh with the id: %s",
+		    "mesh_id",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+	});
+
+	test('should pass with valid args if autoConfirmAction flag is set', async () => {
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'valid_file_name' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: Promise.resolve(true),
+			},
+		});
 
-		const runResult = await UpdateCommand.run([
-			'sample_merchant',
-			'src/commands/__fixtures__/sample_mesh.json',
-		]);
+		const runResult = await UpdateCommand.run();
 
-		expect(runResult).toBe('Update cancelled');
+		expect(runResult).toMatchInlineSnapshot(`
+		Object {
+		  "status": "success",
+		}
+	`);
+		expect(initRequestId).toHaveBeenCalled();
+		expect(promptConfirm).not.toHaveBeenCalled();
+		expect(initSdk).toHaveBeenCalledWith({
+			ignoreCache: true,
+		});
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Successfully updated the mesh with the id: %s",
+		    "mesh_id",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
 	});
 });

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

@@ -11,18 +11,34 @@ governing permissions and limitations under the License.
 
 const { Command } = require('@oclif/command');
 const { readFile } = require('fs/promises');
-const { initSdk, initRequestId } = require('../../helpers');
+
+const { initSdk, initRequestId, promptConfirm } = require('../../helpers');
 const logger = require('../../classes/logger');
+const CONSTANTS = require('../../constants');
+const { ignoreCacheFlag, autoConfirmActionFlag } = require('../../utils');
+const {
+	createMesh,
+	createAPIMeshCredentials,
+	subscribeCredentialToMeshService,
+} = require('../../lib/devConsole');
+
+require('dotenv').config();
+
+const { MULTITENANT_GRAPHQL_SERVER_BASE_URL } = CONSTANTS;
 
 class CreateCommand extends Command {
 	static args = [{ name: 'file' }];
+	static flags = {
+		ignoreCache: ignoreCacheFlag,
+		autoConfirmAction: autoConfirmActionFlag,
+	};
 
 	async run() {
 		await initRequestId();
 
 		logger.info(`RequestId: ${global.requestId}`);
 
-		const { args } = this.parse(CreateCommand);
+		const { args, flags } = await this.parse(CreateCommand);
 
 		if (!args.file) {
 			this.error('Missing file path. Run aio api-mesh create --help for more info.');
@@ -30,7 +46,12 @@ class CreateCommand extends Command {
 			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;
 
@@ -45,25 +66,78 @@ class CreateCommand extends Command {
 			);
 		}
 
-		try {
-			const mesh = await schemaServiceClient.createMesh(imsOrgId, projectId, workspaceId, data);
+		let shouldContinue = true;
 
-			if (mesh) {
-				this.log('Successfully created mesh %s', mesh.meshId);
-				this.log(JSON.stringify(mesh, null, 2));
+		if (!autoConfirmAction) {
+			shouldContinue = await promptConfirm(`Are you sure you want to create a mesh?`);
+		}
 
-				return mesh;
-			} else {
-				this.error(`Unable to create a mesh. Please try again. RequestId: ${global.requestId}`, {
-					exit: false,
-				});
+		if (shouldContinue) {
+			try {
+				const mesh = await createMesh(imsOrgId, projectId, workspaceId, data);
+				let sdkList = [];
+
+				if (mesh) {
+					this.log('Successfully created mesh %s', mesh.meshId);
+					this.log(JSON.stringify(mesh, null, 2));
+					// create API key credential
+					const adobeIdIntegrationsForWorkspace = await createAPIMeshCredentials(
+						imsOrgId,
+						projectId,
+						workspaceId,
+					);
+
+					if (adobeIdIntegrationsForWorkspace) {
+						this.log('Successfully created API Key %s', adobeIdIntegrationsForWorkspace.apiKey);
+						// subscribe the credential to API mesh service
+						sdkList = await subscribeCredentialToMeshService(
+							imsOrgId,
+							projectId,
+							workspaceId,
+							adobeIdIntegrationsForWorkspace.id,
+						);
+
+						if (sdkList) {
+							this.log(
+								'Successfully subscribed API Key %s to API Mesh service',
+								adobeIdIntegrationsForWorkspace.apiKey,
+							);
+
+							this.log(
+								'Mesh Endpoint: %s\n',
+								`${MULTITENANT_GRAPHQL_SERVER_BASE_URL}/${mesh.meshId}/graphql?api_key=${adobeIdIntegrationsForWorkspace.apiKey}`,
+							);
+						} else {
+							this.log(
+								'Unable to subscribe API Key %s to API Mesh service',
+								adobeIdIntegrationsForWorkspace.apiKey,
+							);
+						}
+					} else {
+						this.log('Unable to create API Key');
+					}
+
+					return {
+						adobeIdIntegrationsForWorkspace,
+						sdkList,
+						mesh,
+					};
+				} else {
+					this.error(`Unable to create a mesh. Please try again. RequestId: ${global.requestId}`, {
+						exit: false,
+					});
+				}
+			} catch (error) {
+				this.log(error.message);
+
+				this.error(
+					`Unable to create a mesh. Please check the mesh configuration file and try again. If the error persists please contact support. RequestId: ${global.requestId}`,
+				);
 			}
-		} catch (error) {
-			this.log(error.message);
+		} else {
+			this.log('Create cancelled');
 
-			this.error(
-				`Unable to create a mesh. Please check the mesh configuration file and try again. If the error persists please contact support. RequestId: ${global.requestId}`,
-			);
+			return 'Create cancelled';
 		}
 	}
 }

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

@@ -13,54 +13,101 @@ const { Command } = require('@oclif/command');
 
 const logger = require('../../classes/logger');
 const { initSdk, initRequestId, promptConfirm } = require('../../helpers');
+const { ignoreCacheFlag, autoConfirmActionFlag } = require('../../utils');
+const {
+	getMeshId,
+	deleteMesh,
+	getApiKeyCredential,
+	unsubscribeCredentialFromMeshService,
+} = require('../../lib/devConsole');
 
 require('dotenv').config();
 
 class DeleteCommand extends Command {
-	static args = [{ name: 'meshId' }];
+	static flags = {
+		ignoreCache: ignoreCacheFlag,
+		autoConfirmAction: autoConfirmActionFlag,
+	};
 
 	async run() {
 		await initRequestId();
 
 		logger.info(`RequestId: ${global.requestId}`);
 
-		const { args } = this.parse(DeleteCommand);
+		const { flags } = await this.parse(DeleteCommand);
 
-		if (!args.meshId) {
-			this.error('Missing Mesh ID. Run aio api-mesh delete --help for more info.');
+		const ignoreCache = await flags.ignoreCache;
+		const autoConfirmAction = await flags.autoConfirmAction;
 
-			return;
-		}
-
-		const { schemaServiceClient, imsOrgId, projectId, workspaceId } = await initSdk();
+		const { imsOrgId, projectId, workspaceId } = await initSdk({
+			ignoreCache,
+		});
 
-		const shouldContinue = await promptConfirm(
-			`Are you sure you want to delete the mesh: ${args.meshId}?`,
-		);
-
-		if (shouldContinue) {
-			try {
-				const response = await schemaServiceClient.deleteMesh(
-					imsOrgId,
-					projectId,
-					workspaceId,
-					args.meshId,
-				);
+		let meshId = null;
 
-				this.log('Successfully deleted mesh %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 delete mesh. Please check the details and try again. If the error persists please contact support. RequestId: ${global.requestId}`,
+			if (!autoConfirmAction) {
+				shouldContinue = await promptConfirm(
+					`Are you sure you want to delete the mesh: ${meshId}?`,
 				);
 			}
-		} else {
-			this.log('Delete cancelled');
 
-			return 'Delete cancelled';
+			if (shouldContinue) {
+				try {
+					const deleteMeshResponse = await deleteMesh(imsOrgId, projectId, workspaceId, meshId);
+
+					if (deleteMeshResponse) {
+						this.log('Successfully deleted mesh %s', meshId);
+
+						const credential = await getApiKeyCredential(imsOrgId, projectId, workspaceId);
+
+						if (credential) {
+							const newSDKList = await unsubscribeCredentialFromMeshService(
+								imsOrgId,
+								projectId,
+								workspaceId,
+								credential.id_integration,
+							);
+
+							if (newSDKList) {
+								this.log('Successfully unsubscribed API Key %s', credential.client_id);
+							} else {
+								this.log('Unable to unsubscribe API Key %s', credential.client_id);
+							}
+						} else {
+							this.log('No API Key found to unsubscribe');
+						}
+
+						return deleteMeshResponse;
+					} else {
+						throw new Error('Unable to delete mesh');
+					}
+				} catch (error) {
+					this.log(error.message);
+
+					this.error(
+						`Unable to delete mesh. Please check the details and try again. If the error persists please contact support. RequestId: ${global.requestId}`,
+					);
+				}
+			} else {
+				this.log('Delete cancelled');
+
+				return 'Delete cancelled';
+			}
+		} else {
+			this.error(
+				`Unable to delete. No mesh found for Org(${imsOrgId}) -> Project(${projectId}) -> Workspace(${workspaceId}). Please check the details and try again.`,
+			);
 		}
 	}
 }

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

@@ -10,24 +10,40 @@ governing permissions and limitations under the License.
 */
 
 const { Command } = require('@oclif/command');
+
 const logger = require('../../classes/logger');
 const { initSdk, initRequestId } = require('../../helpers');
+const CONSTANTS = require('../../constants');
+const { ignoreCacheFlag } = require('../../utils');
+const { describeMesh } = require('../../lib/devConsole');
 
 require('dotenv').config();
 
+const { MULTITENANT_GRAPHQL_SERVER_BASE_URL } = CONSTANTS;
+
 class DescribeCommand extends Command {
+	static flags = {
+		ignoreCache: ignoreCacheFlag,
+	};
+
 	async run() {
 		await initRequestId();
 
 		logger.info(`RequestId: ${global.requestId}`);
 
-		const { schemaServiceClient, imsOrgId, projectId, workspaceId } = await initSdk();
+		const { flags } = await this.parse(DescribeCommand);
+
+		const ignoreCache = await flags.ignoreCache;
+
+		const { imsOrgId, projectId, workspaceId } = await initSdk({
+			ignoreCache,
+		});
 
 		try {
-			const meshDetails = await schemaServiceClient.describeMesh(imsOrgId, projectId, workspaceId);
+			const meshDetails = await describeMesh(imsOrgId, projectId, workspaceId);
 
 			if (meshDetails) {
-				const { meshId } = meshDetails;
+				const { meshId, apiKey } = meshDetails;
 
 				if (meshId) {
 					this.log('Successfully retrieved mesh details \n');
@@ -36,6 +52,14 @@ class DescribeCommand extends Command {
 					this.log('Workspace ID: %s', workspaceId);
 					this.log('Mesh ID: %s', meshId);
 
+					if (apiKey) {
+						this.log('API Key: %s', apiKey);
+						this.log(
+							'Mesh Endpoint: %s\n',
+							`${MULTITENANT_GRAPHQL_SERVER_BASE_URL}/${meshId}/graphql?api_key=${apiKey}`,
+						);
+					}
+
 					return meshDetails;
 				} else {
 					this.error(