@adobe/aio-cli-plugin-api-mesh 5.2.3 → 5.2.4-alpha.0

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

@@ -13,7 +13,6 @@ const { Command } = require('@oclif/core');
 const {
 	portNoFlag,
 	debugFlag,
-	inspectPortNoFlag,
 	selectFlag,
 	envFileFlag,
 	secretsFlag,
@@ -36,17 +35,10 @@ const {
 	writeSecretsFile,
 } = require('../../helpers');
 const logger = require('../../classes/logger');
-const { getMeshId, getMeshArtifact } = require('../../lib/devConsole');
+const { getMeshId, getMeshArtifact } = require('../../lib/smsClient');
 require('dotenv').config();
-const { start } = require('../../wranglerCli');
-const {
-	resolveOriginalSources,
-	copyBuiltMeshToPackage,
-	BUILT_MESH_ARTIFACT_DIRECTORY,
-	safeDelete,
-	getBuiltMeshTenantDirectory,
-} = require('../../project');
-const { resolveRelativeSources } = require('../../meshArtifact');
+const { runServer } = require('../../server');
+const { fixPlugins } = require('../../fixPlugins');
 
 const { validateMesh, buildMesh, compileMesh } = meshBuilder.default;
 
@@ -63,7 +55,6 @@ class RunCommand extends Command {
 
 	static flags = {
 		port: portNoFlag,
-		inspectPort: inspectPortNoFlag,
 		debug: debugFlag,
 		env: envFileFlag,
 		autoConfirmAction: autoConfirmActionFlag,
@@ -75,219 +66,182 @@ class RunCommand extends Command {
 
 	static examples = [];
 
-	/**
-	 * 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.',
-			);
-		}
-	}
-
-	/**
-	 * 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({});
-
-		// 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}`,
-			);
-		}
-
-		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');
-		}
-
-		// Resolve relative sources in built mesh for local development
-		const builtMeshTenantDir = getBuiltMeshTenantDirectory(meshId);
-		await resolveRelativeSources(builtMeshTenantDir);
-
-		this.log('Successfully downloaded mesh');
-
-		return meshId;
-	}
+	async run() {
+		await initRequestId();
 
-	/**
-	 * 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.');
-		}
+		logger.info(`RequestId: ${global.requestId}`);
 
-		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.');
-			}
-		}
+		const { args, flags } = await this.parse(RunCommand);
+		const secretsFilePath = await flags.secrets;
 
-		let filesList = [];
+		//Initialize the meshId based on
+		let meshId = null;
 
 		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);
+			//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 {
 				throw new Error(
-					'Unable to import the files in the mesh config. Please check the file and try again.',
+					'`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.',
 				);
 			}
+		} 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;
 	}
 
-	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',
-			);
+	async copyMeshContent(meshId) {
+		// Remove mesh artifact directory if exists
+		if (fs.existsSync('.mesh')) {
+			fs.rmSync('.mesh', { 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 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 });
 		}
-		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.');
-			}
+		// 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');
 		}
-	}
 
-	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);
-			}
+		await fixPlugins('.mesh/index.js');
 
-			//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);
+		if (fs.existsSync(`${__dirname}/../../../.mesh`)) {
+			fs.rmSync(`${__dirname}/../../../.mesh`, { recursive: true });
 		}
+		// At this time the bundle and build files must be copied out to the plugin directory
+		fs.cpSync('.mesh', `${__dirname}/../../../.mesh`, { recursive: true });
+		// Tenant files used at build time
+		fs.cpSync('tenantFiles', `${__dirname}/../../../tenantFiles`, { recursive: true });
 	}
 }
 

package/src/commands/api-mesh/source/__tests__/install.test.js

@@ -20,13 +20,13 @@ const mockSources = { '0.0.1-test-03': mockSourceTest03v1Fixture };
 jest.mock('source-registry-storage-adapter');
 jest.mock('../../../../helpers');
 const InstallCommand = require('../install');
-const { getMeshId, getMesh, updateMesh } = require('../../../../lib/devConsole');
+const { getMeshId, getMesh, updateMesh } = require('../../../../lib/smsClient');
 const mockGetMeshConfig = require('../../../__fixtures__/sample_mesh.json');
 const selectedOrg = { id: '1234', code: 'CODE1234@AdobeOrg', name: 'ORG01', type: 'entp' };
 const selectedProject = { id: '5678', title: 'Project01' };
 const selectedWorkspace = { id: '123456789', title: 'Workspace01' };
 global.requestId = 'dummy_request_id';
-jest.mock('../../../../lib/devConsole');
+jest.mock('../../../../lib/smsClient');
 mockAdapter.mockImplementation(() => ({
 	get: jest.fn().mockResolvedValue(mockSources[`0.0.1-test-03`]),
 	getList: jest.fn().mockImplementation(() => mockMetadataFixture),

package/src/commands/api-mesh/source/install.js

@@ -18,7 +18,7 @@ const config = require('@adobe/aio-lib-core-config');
 const logger = require('../../../classes/logger');
 const { readFile } = require('fs/promises');
 const chalk = require('chalk');
-const { getMeshId, getMesh, updateMesh } = require('../../../lib/devConsole');
+const { getMeshId, getMesh, updateMesh } = require('../../../lib/smsClient');
 const JsonInterpolate = require('json-interpolate');
 
 class InstallCommand extends Command {

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

@@ -2,7 +2,7 @@ const { Command } = require('@oclif/core');
 
 const logger = require('../../classes/logger');
 const { initRequestId, initSdk } = require('../../helpers');
-const { getMeshId, getMesh, getMeshDeployments } = require('../../lib/devConsole');
+const { getMeshId, getMesh, getMeshDeployments } = require('../../lib/smsClient');
 const { ignoreCacheFlag } = require('../../utils');
 
 require('dotenv').config();

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

@@ -26,7 +26,7 @@ const {
 	validateSecretsFile,
 	encryptSecrets,
 } = require('../../utils');
-const { getMeshId, updateMesh, getPublicEncryptionKey } = require('../../lib/devConsole');
+const { getMeshId, updateMesh, getPublicEncryptionKey } = require('../../lib/smsClient');
 
 class UpdateCommand extends Command {
 	static args = [{ name: 'file' }];
@@ -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,7 +119,8 @@ class UpdateCommand extends Command {
 				await validateSecretsFile(secretsFilePath);
 				const secretsData = await interpolateSecrets(secretsFilePath, this);
 				const publicKey = await getPublicEncryptionKey(imsOrgCode);
-				data.secrets = await encryptSecrets(publicKey, secretsData);
+				const encryptedSecrets = await encryptSecrets(publicKey, secretsData);
+				data.secrets = encryptedSecrets;
 			} catch (err) {
 				this.log(err.message);
 				this.error('Unable to import secrets. Check the file and try again.');

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 Promise<boolean>
+ * @returns boolean
  */
 async function promptConfirm(message) {
 	const prompt = inquirer.createPromptModule({ output: process.stderr });
@@ -505,6 +505,7 @@ 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) {
@@ -519,15 +520,31 @@ async function promptInput(message) {
 	return selected.item;
 }
 
+/**
+ * Function to prompt for a secret/password input that masks the characters
+ *
+ * @param {string} message - prompt message
+ * @returns {Promise<string>} - the entered secret value
+ */
+async function promptInputSecret(message) {
+	const selected = await inquirer.prompt([
+		{
+			name: 'item',
+			message,
+			type: 'password',
+		},
+	]);
+
+	return selected.item;
+}
+
 /**
  * Import the files in the files array in meshConfig
  *
  * @param data MeshConfig
- * @param filesListArray List of files in meshConfig
+ * @param filesList 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,
@@ -590,38 +607,29 @@ 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(fileName)} file?`,
+			`Do you want to override the ${path.basename(overrideArr[i].fileName)} file?`,
 		);
 
 		if (shouldOverride) {
 			resultData = updateFilesArray(
 				resultData,
-				fileName,
+				overrideArr[i].fileName,
 				meshConfigName,
 				overrideArr[i].index,
 				shouldMinifyJS,
 			);
-			localFileOverrides[fileName] = true;
-		} else {
-			localFileOverrides[fileName] = false;
 		}
 	}
 
-	return {
-		data: resultData,
-		localFileOverrides,
-	};
+	return resultData;
 }
 
 /**loads the pupa module dynamically and then interpolates the raw data from mesh file with object data
- * @param data
- * @param obj
- * @returns {object}
+ * @param {data}
+ * @param {obj}
+ * @returns {object} having interpolationStatus, missingKeys and interpolatedMesh
  */
 
 async function interpolateMesh(data, obj) {
@@ -855,7 +863,7 @@ async function processFileConfig(config) {
  * This function sets up the tenantFiles used in a particular mesh config
  * into the tenantFiles folder
  *
- * @param meshId
+ * @param config
  */
 async function setUpTenantFiles(meshId) {
 	if (fs.existsSync(path.resolve(process.cwd(), 'mesh-artifact', meshId, 'files.json'))) {
@@ -959,6 +967,7 @@ module.exports = {
 	objToString,
 	promptInput,
 	promptConfirm,
+	promptInputSecret,
 	getLibConsoleCLI,
 	getDevConsoleConfig,
 	initSdk,

package/src/{worker.js → index.js}

@@ -1,7 +1,7 @@
 import { ServedTier, addServedHeader } from './served';
-import { buildServer } from './server';
 import { bindedlogger as logger } from './utils/logger';
 import { getRequestId } from './utils/requestId';
+import { buildServer } from './wranglerServer';
 
 let server;
 
@@ -21,10 +21,10 @@ export default {
 		const { MESH_ID: meshId, LOG_LEVEL: logLevel } = env;
 		const loggerInstance = logger({ logLevel, meshId, requestId });
 		const meshArtifacts = await import('../.mesh');
-		const meshConfig = await import('../.mesh/.meshrc.json');
+		const rawMesh = await import('../.mesh/.meshrc.json');
 
 		if (!server) {
-			server = await this.buildAndCacheServer(env, loggerInstance, meshArtifacts, meshConfig);
+			server = await this.buildAndCacheServer(env, loggerInstance, meshArtifacts, rawMesh);
 		}
 
 		loggerInstance.debug('WORKER HOT: Fetching via worker');
@@ -34,13 +34,11 @@ export default {
 	},
 	/**
 	 * Build and cache mesh instance/server in global variable.
-	 * @param env Environment
-	 * @param logger Logger
-	 * @param meshArtifacts Mesh artifact
-	 * @param meshConfig Mesh config
+	 * @param env
+	 * @param loggerInstance
 	 */
-	async buildAndCacheServer(env, logger, meshArtifacts, meshConfig) {
-		server = await buildServer(logger, env, meshArtifacts, meshConfig);
+	async buildAndCacheServer(env, loggerInstance, meshArtifacts, meshConfig) {
+		server = await buildServer(loggerInstance, env, meshArtifacts, meshConfig);
 		return server;
 	},
 };