@adobe/aio-cli-plugin-api-mesh 2.2.0 → 2.2.1

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

@@ -17,6 +17,7 @@ jest.mock('../../../helpers', () => ({
 	initSdk: jest.fn().mockResolvedValue({}),
 	initRequestId: jest.fn().mockResolvedValue({}),
 	promptConfirm: jest.fn().mockResolvedValue(true),
+	importFiles: jest.fn().mockResolvedValue(),
 }));
 jest.mock('@adobe/aio-cli-lib-console', () => ({
 	init: jest.fn().mockResolvedValue(mockConsoleCLIInstance),
@@ -34,7 +35,7 @@ const selectedWorkspace = { id: '123456789', title: 'Workspace01' };
 const { readFile } = require('fs/promises');
 
 const UpdateCommand = require('../update');
-const { initSdk, initRequestId, promptConfirm } = require('../../../helpers');
+const { initSdk, initRequestId, promptConfirm, importFiles } = require('../../../helpers');
 const { getMeshId, updateMesh } = require('../../../lib/devConsole');
 
 let logSpy = null;
@@ -58,7 +59,7 @@ describe('update command tests', () => {
 		logSpy = jest.spyOn(UpdateCommand.prototype, 'log');
 		errorLogSpy = jest.spyOn(UpdateCommand.prototype, 'error');
 
-		readFile.mockResolvedValue(true);
+		readFile.mockResolvedValue('{}');
 
 		getMeshId.mockResolvedValue('mesh_id');
 		updateMesh.mockResolvedValue({ status: 'success' });
@@ -74,6 +75,30 @@ describe('update command tests', () => {
 	});
 
 	test('should pass with valid args', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
 		const runResult = await UpdateCommand.run();
 
 		expect(runResult).toMatchInlineSnapshot(`
@@ -109,8 +134,24 @@ describe('update command tests', () => {
 	});
 
 	test('should pass with valid args and ignoreCache flag', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
 		parseSpy.mockResolvedValueOnce({
-			args: { file: 'valid_file_name' },
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
 			flags: {
 				ignoreCache: Promise.resolve(true),
 				autoConfirmAction: mockAutoApproveAction,
@@ -152,8 +193,24 @@ describe('update command tests', () => {
 	});
 
 	test('should pass with valid args if autoConfirmAction flag is set', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
 		parseSpy.mockResolvedValueOnce({
-			args: { file: 'valid_file_name' },
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
 			flags: {
 				ignoreCache: mockIgnoreCacheFlag,
 				autoConfirmAction: Promise.resolve(true),
@@ -196,6 +253,30 @@ describe('update command tests', () => {
 	});
 
 	test('should fail if mesh id is missing', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
 		getMeshId.mockResolvedValue(null);
 		const runResult = UpdateCommand.run();
 
@@ -213,6 +294,30 @@ describe('update command tests', () => {
 	});
 
 	test('should fail if getMeshId api failed', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
 		getMeshId.mockRejectedValue(new Error('getMeshId api failed'));
 		const runResult = UpdateCommand.run();
 
@@ -230,6 +335,30 @@ describe('update command tests', () => {
 	});
 
 	test('should fail if updateMesh method failed', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
 		updateMesh.mockRejectedValueOnce(new Error('dummy_error'));
 
 		const runResult = UpdateCommand.run();
@@ -308,6 +437,30 @@ describe('update command tests', () => {
 	});
 
 	test('should not update if user prompt returns false', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
 		promptConfirm.mockResolvedValueOnce(false);
 
 		const runResult = await UpdateCommand.run();
@@ -322,4 +475,266 @@ describe('update command tests', () => {
 	`);
 		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`[]`);
 	});
+
+	test('should pass if there are local files in meshConfig i.e., the file is appended in files array', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<json_source_name>',
+						handler: {
+							JsonSchema: {
+								baseUrl: '<json_source__baseurl>',
+								operations: [
+									{
+										type: 'Query',
+										field: '<query>',
+										path: '<query_path>',
+										method: 'POST',
+										requestSchema: './requestParams.json',
+									},
+								],
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		let meshConfig = {
+			sources: [
+				{
+					name: '<json_source_name>',
+					handler: {
+						JsonSchema: {
+							baseUrl: '<json_source__baseurl>',
+							operations: [
+								{
+									type: 'Query',
+									field: '<query>',
+									path: '<query_path>',
+									method: 'POST',
+									requestSchema: './requestParams.json',
+								},
+							],
+						},
+					},
+				},
+			],
+			files: [
+				{
+					path: './requestParams.json',
+					content: '{"type":"updatedContent"}',
+				},
+			],
+		};
+
+		updateMesh.mockResolvedValue({
+			meshId: 'dummy_mesh_id',
+			meshConfig: meshConfig,
+		});
+
+		parseSpy.mockResolvedValue({
+			args: { file: 'src/commands/__fixtures__/sample_mesh_files.json' },
+			flags: {
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
+		importFiles.mockResolvedValueOnce({
+			meshConfig,
+		});
+
+		const output = await UpdateCommand.run();
+
+		expect(initRequestId).toHaveBeenCalled();
+		expect(updateMesh.mock.calls[0]).toMatchInlineSnapshot(`
+		[
+		  "1234",
+		  "5678",
+		  "123456789",
+		  "mesh_id",
+		  {
+		    "meshConfig": {
+		      "files": [
+		        {
+		          "content": "{"type":"updatedContent"}",
+		          "path": "./requestParams.json",
+		        },
+		      ],
+		      "sources": [
+		        {
+		          "handler": {
+		            "JsonSchema": {
+		              "baseUrl": "<json_source__baseurl>",
+		              "operations": [
+		                {
+		                  "field": "<query>",
+		                  "method": "POST",
+		                  "path": "<query_path>",
+		                  "requestSchema": "./requestParams.json",
+		                  "type": "Query",
+		                },
+		              ],
+		            },
+		          },
+		          "name": "<json_source_name>",
+		        },
+		      ],
+		    },
+		  },
+		]
+	`);
+
+		expect(output).toMatchInlineSnapshot(`
+		{
+		  "meshConfig": {
+		    "files": [
+		      {
+		        "content": "{"type":"updatedContent"}",
+		        "path": "./requestParams.json",
+		      },
+		    ],
+		    "sources": [
+		      {
+		        "handler": {
+		          "JsonSchema": {
+		            "baseUrl": "<json_source__baseurl>",
+		            "operations": [
+		              {
+		                "field": "<query>",
+		                "method": "POST",
+		                "path": "<query_path>",
+		                "requestSchema": "./requestParams.json",
+		                "type": "Query",
+		              },
+		            ],
+		          },
+		        },
+		        "name": "<json_source_name>",
+		      },
+		    ],
+		  },
+		  "meshId": "dummy_mesh_id",
+		}
+	`);
+	});
+
+	test('should fail if the input mesh config file is inavlid i.e., file name has more than 25 characters', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<json_source_name>',
+						handler: {
+							JsonSchema: {
+								baseUrl: '<json_source__baseurl>',
+								operations: [
+									{
+										type: 'Query',
+										field: '<query>',
+										path: '<query_path>',
+										method: 'POST',
+										requestSchema: './requestJSONParameters.json',
+									},
+								],
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValue({
+			args: { file: 'src/commands/__fixtures__/sample_mesh_invalid_file_name.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
+		const output = UpdateCommand.run();
+
+		await expect(output).rejects.toEqual(new Error('Input mesh config is not valid.'));
+
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		[
+		  [
+		    "Mesh file names must be less than 25 characters. The following file(s) are invalid: requestJSONParameters.json.",
+		  ],
+		]
+	`);
+
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		[
+		  [
+		    "Input mesh config is not valid.",
+		  ],
+		]
+	`);
+	});
+
+	test('should fail if the import files function fails', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<json_source_name>',
+						handler: {
+							JsonSchema: {
+								baseUrl: '<json_source__baseurl>',
+								operations: [
+									{
+										type: 'Query',
+										field: '<query>',
+										path: '<query_path>',
+										method: 'POST',
+										requestSchema: './requestParams.json',
+									},
+								],
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValue({
+			args: { file: 'src/commands/__fixtures__/sample_mesh_files.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
+		importFiles.mockImplementation(() => {
+			throw new Error('Error reading the file.');
+		});
+
+		const output = UpdateCommand.run();
+		await expect(output).rejects.toEqual(
+			new Error(
+				'Unable to import the files in the mesh config. Please check the file and try again.',
+			),
+		);
+
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		[
+		  [
+		    "Error reading the file.",
+		  ],
+		]
+	`);
+
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		[
+		  [
+		    "Unable to import the files in the mesh config. Please check the file and try again.",
+		  ],
+		]
+	`);
+	});
 });

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

@@ -10,22 +10,26 @@ governing permissions and limitations under the License.
 */
 
 const { Command } = require('@oclif/core');
-const { readFile } = require('fs/promises');
 
-const { initSdk, initRequestId, promptConfirm } = require('../../helpers');
+const { initSdk, initRequestId, promptConfirm, importFiles } = require('../../helpers');
 const logger = require('../../classes/logger');
 const CONSTANTS = require('../../constants');
-const { ignoreCacheFlag, autoConfirmActionFlag, jsonFlag, envFileFlag } = require('../../utils');
+const {
+	ignoreCacheFlag,
+	autoConfirmActionFlag,
+	jsonFlag,
+	getFilesInMeshConfig,
+	envFileFlag,
+	checkPlaceholders,
+	readFileContents,
+	validateAndInterpolateMesh,
+} = require('../../utils');
 const {
 	createMesh,
 	createAPIMeshCredentials,
 	subscribeCredentialToMeshService,
 } = require('../../lib/devConsole');
 
-const meshInterpolation = require('../../meshInterpolation');
-
-const dotenv = require('dotenv');
-
 const { MULTITENANT_GRAPHQL_SERVER_BASE_URL } = CONSTANTS;
 
 class CreateCommand extends Command {
@@ -54,82 +58,46 @@ class CreateCommand extends Command {
 
 		const ignoreCache = await flags.ignoreCache;
 		const autoConfirmAction = await flags.autoConfirmAction;
-		const envFilePath=await flags.env;
+		const envFilePath = await flags.env;
 		const { imsOrgId, projectId, workspaceId } = await initSdk({
 			ignoreCache,
 		});
 
-		let inputMeshData;
-
 		//Input the mesh data from the input file
-		try {
-			inputMeshData = await readFile(args.file, 'utf8');
-		} catch (error) {
-			logger.error(error);
-
-			this.log(error.message);
-			this.error(
-				'Unable to read the mesh configuration file provided. Please check the file and try again.',
-			);
-		}
+		let inputMeshData = await readFileContents(args.file, this, 'mesh');
 
 		let data;
 
-		if (envFilePath) {
-			let envFileContent;
-
-			//Read the environment file
+		if (checkPlaceholders(inputMeshData)) {
+			this.log('The provided mesh contains placeholders. Starting mesh interpolation process.');
+			data = await validateAndInterpolateMesh(inputMeshData, envFilePath, this);
+		} else {
 			try {
-				envFileContent = await readFile(envFilePath, 'utf8');
-			} catch (error) {
-				this.log(error.message);
-				this.error('Unable to read the env file provided. Please check the file and try again.');
+				data = JSON.parse(inputMeshData);
+			} catch (err) {
+				this.log(err.message);
+				this.error('Input mesh file is not a valid JSON. Please check the file provided.');
 			}
+		}
 
-			//Validate the env file
-			const envFileValidity = meshInterpolation.validateEnvFileFormat(envFileContent);
-			if (envFileValidity.valid) {
-				//load env file into the process.env object
-				meshInterpolation.clearEnv();
-
-				//Added env at start of each environment variable
-				const envObj = { env: dotenv.config({ path: envFilePath }).parsed };
-
-				let {
-					interpolationStatus,
-					missingKeys,
-					interpolatedMeshData,
-				} = await meshInterpolation.interpolateMesh(inputMeshData, envObj);
-
-				//De-duplicate the missing keys array
-				missingKeys = missingKeys.filter(function (item, index, inputArray) {
-					return inputArray.indexOf(item) == index;
-				});
-
-				if (interpolationStatus == 'failed') {
-					this.error(
-						'The mesh file cannot be interpolated due to missing keys : ' + missingKeys.toString(),
-					);
-				}
+		let filesList = [];
 
-				try {
-					data = JSON.parse(interpolatedMeshData);
-				} catch (err) {
-					this.log(err.message);
-					this.log(interpolatedMeshData);
-					this.error(
-						'Interpolated mesh is not a valid JSON. Please check the generated json file.',
-					);
-				}
-			} else {
-				this.error(`Issue in ${envFilePath} file - ` + envFileValidity.error);
-			}
-		} else {
+		try {
+			filesList = getFilesInMeshConfig(data, args.file);
+		} catch (err) {
+			this.log(err.message);
+			this.error('Input mesh config is not valid.');
+		}
+
+		// if local files are present, import them in files array in meshConfig
+		if (filesList.length) {
 			try {
-				data = JSON.parse(inputMeshData);
+				data = await importFiles(data, filesList, args.file, flags.autoConfirmAction);
 			} catch (err) {
 				this.log(err.message);
-				this.error('Input mesh file is not a valid JSON. Please check the file provided.');
+				this.error(
+					'Unable to import the files in the mesh config. Please check the file and try again.',
+				);
 			}
 		}
 
@@ -142,6 +110,7 @@ class CreateCommand extends Command {
 		if (shouldContinue) {
 			try {
 				const mesh = await createMesh(imsOrgId, projectId, workspaceId, data);
+
 				let sdkList = [];
 
 				if (mesh) {

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

@@ -9,12 +9,12 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-const { Command } = require('@oclif/command');
+const { Command } = require('@oclif/core');
 const { writeFile } = require('fs/promises');
 
 const logger = require('../../classes/logger');
 const { initSdk, initRequestId } = require('../../helpers');
-const { ignoreCacheFlag } = require('../../utils');
+const { ignoreCacheFlag, jsonFlag } = require('../../utils');
 const { getMeshId, getMesh } = require('../../lib/devConsole');
 
 require('dotenv').config();
@@ -23,8 +23,11 @@ class GetCommand extends Command {
 	static args = [{ name: 'file' }];
 	static flags = {
 		ignoreCache: ignoreCacheFlag,
+		json: jsonFlag,
 	};
 
+	static enableJsonFlag = true;
+
 	async run() {
 		await initRequestId();
 
@@ -33,9 +36,11 @@ class GetCommand extends Command {
 		const { args, flags } = await this.parse(GetCommand);
 
 		const ignoreCache = await flags.ignoreCache;
+		const json = await flags.json;
 
 		const { imsOrgId, projectId, workspaceId } = await initSdk({
 			ignoreCache,
+			verbose: !json,
 		});
 
 		let meshId = null;