@adobe/aio-cli-plugin-api-mesh 5.2.2-beta.2 → 5.2.3-alpha

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

@@ -17,7 +17,7 @@ jest.mock('../../../helpers', () => ({
 	initSdk: jest.fn().mockResolvedValue({}),
 	initRequestId: jest.fn().mockResolvedValue({}),
 	promptConfirm: jest.fn().mockResolvedValue(true),
-	importFiles: jest.fn().mockResolvedValue(),
+	importFiles: jest.fn().mockResolvedValue({}),
 }));
 jest.mock('@adobe/aio-cli-lib-console', () => ({
 	init: jest.fn().mockResolvedValue(mockConsoleCLIInstance),
@@ -547,7 +547,9 @@ describe('update command tests', () => {
 		});
 
 		importFiles.mockResolvedValueOnce({
-			meshConfig,
+			data: {
+				meshConfig,
+			},
 		});
 
 		const output = await UpdateCommand.run();

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

@@ -99,7 +99,7 @@ class CreateCommand extends Command {
 		// if local files are present, import them in files array in meshConfig
 		if (filesList.length) {
 			try {
-				data = await importFiles(data, filesList, args.file, flags.autoConfirmAction);
+				({ data } = await importFiles(data, filesList, args.file, flags.autoConfirmAction));
 			} catch (err) {
 				this.log(err.message);
 				this.error('Unable to import the files in the mesh config. Check the file and try again.');
@@ -112,8 +112,7 @@ class CreateCommand extends Command {
 				await validateSecretsFile(secretsFilePath);
 				const secretsData = await interpolateSecrets(secretsFilePath, this);
 				const publicKey = await getPublicEncryptionKey(imsOrgCode);
-				const encryptedSecrets = await encryptSecrets(publicKey, secretsData);
-				data.secrets = encryptedSecrets;
+				data.secrets = await encryptSecrets(publicKey, secretsData);
 			} catch (err) {
 				this.log(err.message);
 				this.error('Unable to import secrets. Check the file and try again.');

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

@@ -13,6 +13,7 @@ const { Command } = require('@oclif/core');
 const {
 	portNoFlag,
 	debugFlag,
+	inspectPortNoFlag,
 	selectFlag,
 	envFileFlag,
 	secretsFlag,
@@ -37,8 +38,15 @@ const {
 const logger = require('../../classes/logger');
 const { getMeshId, getMeshArtifact } = require('../../lib/devConsole');
 require('dotenv').config();
-const { runServer } = require('../../server');
-const { fixPlugins } = require('../../fixPlugins');
+const { start } = require('../../wranglerCli');
+const {
+	resolveOriginalSources,
+	copyBuiltMeshToPackage,
+	BUILT_MESH_ARTIFACT_DIRECTORY,
+	safeDelete,
+	getBuiltMeshTenantDirectory,
+} = require('../../project');
+const { resolveRelativeSources } = require('../../meshArtifact');
 
 const { validateMesh, buildMesh, compileMesh } = meshBuilder.default;
 
@@ -55,6 +63,7 @@ class RunCommand extends Command {
 
 	static flags = {
 		port: portNoFlag,
+		inspectPort: inspectPortNoFlag,
 		debug: debugFlag,
 		env: envFileFlag,
 		autoConfirmAction: autoConfirmActionFlag,
@@ -66,182 +75,219 @@ class RunCommand extends Command {
 
 	static examples = [];
 
-	async run() {
-		await initRequestId();
+	/**
+	 * Validate the current working directory to ensure it is set up to run the command
+	 * @returns {Promise<void>}
+	 * @throws {Error} when project is not set up correctly
+	 */
+	async validateCwd() {
+		//Ensure that current directory includes package.json
+		if (!fs.existsSync(path.join(process.cwd(), 'package.json'))) {
+			throw new Error(
+				'`aio api-mesh run` cannot be executed because there is no package.json file in the current directory. Use `aio api-mesh init` to set up a package.',
+			);
+		}
+	}
 
-		logger.info(`RequestId: ${global.requestId}`);
+	/**
+	 * Handle remote mesh artifact
+	 * @returns {Promise<string>} Mesh identifier
+	 * @throws {Error} when failure retrieving remote mesh artifact
+	 */
+	async handleRemoteMeshArtifact() {
+		const { imsOrgCode, projectId, workspaceId, workspaceName } = await initSdk({});
 
-		const { args, flags } = await this.parse(RunCommand);
-		const secretsFilePath = await flags.secrets;
+		// Get the mesh identifier for the workspace
+		let meshId;
+		try {
+			meshId = await getMeshId(imsOrgCode, projectId, workspaceId, workspaceName);
+		} catch (err) {
+			throw new Error(
+				`Unable to get mesh ID. Please check the details and try again. RequestId: ${global.requestId}`,
+			);
+		}
 
-		//Initialize the meshId based on
-		let meshId = null;
+		try {
+			await getMeshArtifact(imsOrgCode, projectId, workspaceId, workspaceName, meshId);
+		} catch (err) {
+			throw new Error(
+				`Unable to retrieve mesh. Please check the details and try again. RequestId: ${global.requestId}`,
+			);
+		}
 
 		try {
-			//Ensure that current directory includes package.json
-			if (fs.existsSync(path.join(process.cwd(), 'package.json'))) {
-				//If select flag is present then getMeshId for the specified org
-				if (flags.select) {
-					const { imsOrgCode, projectId, workspaceId, workspaceName } = await initSdk({});
-
-					try {
-						meshId = await getMeshId(imsOrgCode, projectId, workspaceId, workspaceName);
-					} catch (err) {
-						throw new Error(
-							`Unable to get mesh ID. Please check the details and try again. RequestId: ${global.requestId}`,
-						);
-					}
-
-					try {
-						await getMeshArtifact(imsOrgCode, projectId, workspaceId, workspaceName, meshId);
-					} catch (err) {
-						throw new Error(
-							`Unable to retrieve mesh. Please check the details and try again. RequestId: ${global.requestId}`,
-						);
-					}
-
-					try {
-						await setUpTenantFiles(meshId);
-					} catch (err) {
-						throw new Error('Failed to install downloaded mesh');
-					}
-
-					this.log('Successfully downloaded mesh');
-				} else {
-					if (!args.file) {
-						throw new Error('Missing file path. Run aio api-mesh run --help for more info.');
-					}
-
-					const envFilePath = await flags.env;
-
-					//Read the mesh input file
-					let inputMeshData = await readFileContents(args.file, this, 'mesh');
-					let data;
-
-					if (checkPlaceholders(inputMeshData)) {
-						this.log(
-							'The provided mesh contains placeholders. Starting mesh interpolation process.',
-						);
-						data = await validateAndInterpolateMesh(inputMeshData, envFilePath, this);
-					} else {
-						try {
-							data = JSON.parse(inputMeshData);
-						} catch (err) {
-							this.log(err.message);
-							throw new Error(
-								'Input mesh file is not a valid JSON. Please check the file provided.',
-							);
-						}
-					}
-
-					let filesList = [];
-
-					try {
-						filesList = getFilesInMeshConfig(data, args.file);
-					} catch (err) {
-						this.log(err.message);
-						throw new Error('Input mesh config is not valid.');
-					}
-
-					// if local files are present, import them in files array in meshConfig
-					if (filesList.length) {
-						try {
-							// minification of js will not be done for run command if debugging is enabled
-							data = await importFiles(
-								data,
-								filesList,
-								args.file,
-								flags.autoConfirmAction,
-								!flags.debug,
-							);
-						} catch (err) {
-							this.log(err.message);
-							throw new Error(
-								'Unable to import the files in the mesh config. Please check the file and try again.',
-							);
-						}
-					}
-
-					//Generating unique mesh id
-					meshId = 'testMesh';
-
-					await validateMesh(data.meshConfig);
-					await buildMesh(meshId, data.meshConfig);
-					await compileMesh(meshId);
-				}
-				let portNo;
-				//secrets management
-				if (secretsFilePath) {
-					try {
-						await validateSecretsFile(secretsFilePath);
-						const stringifiedSecrets = await interpolateSecrets(secretsFilePath, this);
-						await writeSecretsFile(stringifiedSecrets, meshId);
-					} catch (error) {
-						this.log(error.message);
-						this.error('Unable to import secrets. Please check the file and try again.');
-					}
-				}
-
-				await this.copyMeshContent(meshId);
-
-				//To set the port number using the environment file
-				if (process.env.PORT !== undefined) {
-					if (isNaN(process.env.PORT) || !Number.isInteger(parseInt(process.env.PORT))) {
-						throw new Error('PORT value in the .env file is not a valid integer');
-					}
-
-					portNo = process.env.PORT;
-				}
-
-				//To set the port number as the provided value in the command
-				if (flags.port !== undefined) {
-					portNo = flags.port;
-				}
-
-				//To set the default port to 5000
-				if (!portNo) {
-					portNo = 5000;
-				}
-				this.log(`Starting server on port : ${portNo}`);
-				await runServer(portNo);
-				this.log(`Server is running on http://localhost:${portNo}/graphql`);
-			} else {
+			await setUpTenantFiles(meshId);
+		} catch (err) {
+			throw new Error('Failed to install downloaded mesh');
+		}
+
+		// Resolve relative sources in built mesh for local development
+		const builtMeshTenantDir = getBuiltMeshTenantDirectory(meshId);
+		await resolveRelativeSources(builtMeshTenantDir);
+
+		this.log('Successfully downloaded mesh');
+
+		return meshId;
+	}
+
+	/**
+	 * Handle local mesh configuration
+	 * @param args {unknown} Arguments
+	 * @param flags {unknown} Flags
+	 * @returns {Promise<string>}
+	 * @throws {Error} when failure building local mesh artifact
+	 */
+	async handleLocalMeshConfig(args, flags) {
+		if (!args.file) {
+			throw new Error('Missing file path. Run aio api-mesh run --help for more info.');
+		}
+
+		const envFilePath = await flags.env;
+
+		//Read the mesh input file
+		let inputMeshData = await readFileContents(args.file, this, 'mesh');
+		let data;
+
+		// TODO: Should we check for secrets in use when no secrets file provided?
+		if (checkPlaceholders(inputMeshData)) {
+			this.log('The provided mesh contains placeholders. Starting mesh interpolation process.');
+			data = await validateAndInterpolateMesh(inputMeshData, envFilePath, this);
+		} else {
+			try {
+				data = JSON.parse(inputMeshData);
+			} catch (err) {
+				this.log(err.message);
+				throw new Error('Input mesh file is not a valid JSON. Please check the file provided.');
+			}
+		}
+
+		let filesList = [];
+
+		try {
+			filesList = getFilesInMeshConfig(data, args.file);
+		} catch (err) {
+			this.log(err.message);
+			throw new Error('Input mesh config is not valid.');
+		}
+
+		// if local files are present, import them in files array in meshConfig
+		let localFileOverrides;
+		if (filesList.length) {
+			try {
+				// minification of js will not be done for run command if debugging is enabled
+				({ data, localFileOverrides } = await importFiles(
+					data,
+					filesList,
+					args.file,
+					flags.autoConfirmAction,
+					!flags.debug,
+				));
+			} catch (err) {
+				this.log(err.message);
 				throw new Error(
-					'`aio api-mesh run` cannot be executed because there is no package.json file in the current directory. Use `aio api-mesh init` to set up a package.',
+					'Unable to import the files in the mesh config. Please check the file and try again.',
 				);
 			}
-		} catch (error) {
-			this.error(error.message);
 		}
+		// Empty mesh-artifact directory
+		safeDelete(BUILT_MESH_ARTIFACT_DIRECTORY);
+
+		//Generating unique mesh id
+		const meshId = 'testMesh';
+		await validateMesh(data.meshConfig);
+		await buildMesh(meshId, data.meshConfig);
+		await compileMesh(meshId);
+
+		// Resolve relative sources in built mesh for local development
+		const builtMeshTenantDir = getBuiltMeshTenantDirectory(meshId);
+		await resolveRelativeSources(builtMeshTenantDir);
+		await resolveOriginalSources(builtMeshTenantDir, localFileOverrides);
+
+		return meshId;
 	}
 
-	async copyMeshContent(meshId) {
-		// Remove mesh artifact directory if exists
-		if (fs.existsSync('.mesh')) {
-			fs.rmSync('.mesh', { recursive: true });
+	updateFlagsFromEnv(flags) {
+		if (process.env.PORT !== undefined) {
+			flags.port = this.parseInt(
+				process.env.PORT,
+				'PORT value in the .env file is not a valid integer',
+			);
+		}
+		if (process.env.INSPECT_PORT !== undefined) {
+			flags.inspectPort = this.parseInt(
+				process.env.INSPECT_PORT,
+				'INSPECT_PORT value in the .env file is not a valid integer',
+			);
 		}
-		// Move built mesh artifact to expect directory
-		fs.renameSync(`mesh-artifact/${meshId}`, '.mesh');
-		// Remove tenant files directory if exists
-		if (fs.existsSync('tenantFiles')) {
-			fs.rmSync('tenantFiles', { recursive: true });
+	}
+
+	/**
+	 * Parse integer from string
+	 * @param value {string} String value
+	 * @param errorMessage {string?} Optional error message when parsing fails
+	 * @returns {number}
+	 * @throws {Error} when value is not a valid integer
+	 */
+	parseInt(value, errorMessage) {
+		const int = parseInt(value);
+		if (isNaN(int) || !Number.isInteger(int)) {
+			throw new Error(errorMessage || `Value is not a valid integer`);
 		}
-		// Move built tenant files if exists
-		if (fs.existsSync('mesh-artifact/tenantFiles')) {
-			// Tenant files included in the bundle for runtime/dynamic imports
-			fs.cpSync('mesh-artifact/tenantFiles', '.mesh/tenantFiles', { recursive: true });
-			fs.renameSync('mesh-artifact/tenantFiles', 'tenantFiles');
-			// Tenant files used at worker build time
-			fs.cpSync('tenantFiles', `${__dirname}/../../../tenantFiles`, { recursive: true });
+		return int;
+	}
+
+	/**
+	 * Handle secrets feature
+	 * @param secretsFilePath {string} File path to secrets
+	 * @param meshId {string} Mesh identifier
+	 * @returns {Promise<void>}
+	 */
+	async handleSecretsFeature(secretsFilePath, meshId) {
+		if (secretsFilePath) {
+			try {
+				await validateSecretsFile(secretsFilePath);
+				const stringifiedSecrets = await interpolateSecrets(secretsFilePath, this);
+				await writeSecretsFile(stringifiedSecrets, meshId);
+			} catch (error) {
+				this.log(error.message);
+				this.error('Unable to import secrets. Please check the file and try again.');
+			}
 		}
+	}
 
-		await fixPlugins('.mesh/index.js');
+	async run() {
+		try {
+			await initRequestId();
+			logger.info(`RequestId: ${global.requestId}`);
+
+			const { args, flags } = await this.parse(RunCommand);
+			await this.validateCwd();
+			this.updateFlagsFromEnv(flags);
+
+			// Use remote or local mesh artifact
+			let meshId;
+			if (flags.select) {
+				meshId = await this.handleRemoteMeshArtifact();
+			} else {
+				meshId = await this.handleLocalMeshConfig(args, flags);
+			}
 
-		if (fs.existsSync(`${__dirname}/../../../.mesh`)) {
-			fs.rmSync(`${__dirname}/../../../.mesh`, { recursive: true });
+			//secrets management
+			const secretsFilePath = await flags.secrets;
+			if (secretsFilePath) {
+				await this.handleSecretsFeature(secretsFilePath, meshId);
+			}
+
+			const builtMeshTenantDir = getBuiltMeshTenantDirectory(meshId);
+			await copyBuiltMeshToPackage(builtMeshTenantDir);
+
+			start(this, flags.port, flags.debug, flags.inspectPort);
+			if (flags.debug) {
+				this.log(`Debugging enabled on inspect port: ${flags.inspectPort}`);
+			}
+		} catch (error) {
+			this.error(error.message);
 		}
-		// At this time the bundle and build files must be copied out to the plugin directory
-		fs.cpSync('.mesh', `${__dirname}/../../../.mesh`, { recursive: true });
 	}
 }
 

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

@@ -106,7 +106,7 @@ class UpdateCommand extends Command {
 		// if local files are present, import them in files array in meshConfig
 		if (filesList.length) {
 			try {
-				data = await importFiles(data, filesList, args.file, flags.autoConfirmAction);
+				({ data } = await importFiles(data, filesList, args.file, flags.autoConfirmAction));
 			} catch (err) {
 				this.log(err.message);
 				this.error('Unable to import the files in the mesh config. Check the file and try again.');
@@ -119,8 +119,7 @@ class UpdateCommand extends Command {
 				await validateSecretsFile(secretsFilePath);
 				const secretsData = await interpolateSecrets(secretsFilePath, this);
 				const publicKey = await getPublicEncryptionKey(imsOrgCode);
-				const encryptedSecrets = await encryptSecrets(publicKey, secretsData);
-				data.secrets = encryptedSecrets;
+				data.secrets = await encryptSecrets(publicKey, secretsData);
 			} catch (err) {
 				this.log(err.message);
 				this.error('Unable to import secrets. Check the file and try again.');

package/src/commands/{PLUGINNAME/__tests__/index.test.js → api-mesh.js}

@@ -10,21 +10,19 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-const IndexCommand = require('..');
+const { Help, Command } = require('@oclif/core');
 
-test('exports', async () => {
-	expect(typeof IndexCommand).toEqual('function');
-});
+/**
+ * API Mesh command. Defers to topic for help text.
+ */
+class ApiMeshCommand extends Command {
+	async run() {
+		const help = new Help(this.config);
+		await help.showHelp(['api-mesh', '--help']);
+	}
+}
 
-describe('command tests', () => {
-	let command;
+ApiMeshCommand.description = 'Create, run, test, and deploy API Mesh';
+ApiMeshCommand.args = [];
 
-	beforeEach(() => {
-		command = new IndexCommand([]);
-	});
-
-	test('run', async () => {
-		command.argv = [];
-		await expect(command.run()).resolves.not.toThrowError();
-	});
-});
+module.exports = ApiMeshCommand;

package/src/helpers.js

@@ -445,7 +445,7 @@ async function initRequestId() {
  * Function to run the CLI Y/N prompt to confirm the user's action
  *
  * @param {string} message
- * @returns boolean
+ * @returns Promise<boolean>
  */
 async function promptConfirm(message) {
 	const prompt = inquirer.createPromptModule({ output: process.stderr });
@@ -505,7 +505,6 @@ async function promptSelect(message, choices) {
  * Function to run the CLI selectable list
  *
  * @param {string} message - prompt message
- * @param {object[]} choices - list of options
  * @returns {object[]} - selected options
  */
 async function promptInput(message) {
@@ -524,9 +523,11 @@ async function promptInput(message) {
  * Import the files in the files array in meshConfig
  *
  * @param data MeshConfig
- * @param filesList List of files in meshConfig
+ * @param filesListArray List of files in meshConfig
  * @param meshConfigName MeshConfigName
  * @param autoConfirmActionFlag The user won't be prompted any questions, if this flag is set
+ * @param shouldMinifyJS
+ * @returns Promise<{{ data, localFileOverrides: string[] }}>
  */
 async function importFiles(
 	data,
@@ -589,29 +590,38 @@ async function importFiles(
 		);
 	}
 
+	// Result of override resolution
+	const localFileOverrides = {};
 	for (let i = 0; i < overrideArr.length; i++) {
+		const fileName = overrideArr[i].fileName;
 		shouldOverride = await promptConfirm(
-			`Do you want to override the ${path.basename(overrideArr[i].fileName)} file?`,
+			`Do you want to override the ${path.basename(fileName)} file?`,
 		);
 
 		if (shouldOverride) {
 			resultData = updateFilesArray(
 				resultData,
-				overrideArr[i].fileName,
+				fileName,
 				meshConfigName,
 				overrideArr[i].index,
 				shouldMinifyJS,
 			);
+			localFileOverrides[fileName] = true;
+		} else {
+			localFileOverrides[fileName] = false;
 		}
 	}
 
-	return resultData;
+	return {
+		data: resultData,
+		localFileOverrides,
+	};
 }
 
 /**loads the pupa module dynamically and then interpolates the raw data from mesh file with object data
- * @param {data}
- * @param {obj}
- * @returns {object} having interpolationStatus, missingKeys and interpolatedMesh
+ * @param data
+ * @param obj
+ * @returns {object}
  */
 
 async function interpolateMesh(data, obj) {
@@ -845,7 +855,7 @@ async function processFileConfig(config) {
  * This function sets up the tenantFiles used in a particular mesh config
  * into the tenantFiles folder
  *
- * @param config
+ * @param meshId
  */
 async function setUpTenantFiles(meshId) {
 	if (fs.existsSync(path.resolve(process.cwd(), 'mesh-artifact', meshId, 'files.json'))) {

package/src/lib/devConsole.js

@@ -1064,7 +1064,7 @@ const getMeshDeployments = async (organizationCode, projectId, workspaceId, mesh
  * As a result, we provide the publicKey used for secrets encryption.
  * The near-term goal is to stop using Dev Console as a proxy for all routes.
  * @param organizationCode
- * @returns string
+ * @returns Promise<string>
  */
 const getPublicEncryptionKey = async organizationCode => {
 	const { accessToken } = await getDevConsoleConfig();