@adobe/aio-cli-plugin-api-mesh 2.0.0 → 2.2.0-beta.1

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

@@ -10,20 +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 } = require('../../utils');
+const {
+	ignoreCacheFlag,
+	autoConfirmActionFlag,
+	jsonFlag,
+	getFilesInMeshConfig,
+	envFileFlag,
+	checkPlaceholders,
+	readFileContents,
+	validateAndInterpolateMesh,
+} = require('../../utils');
 const {
 	createMesh,
 	createAPIMeshCredentials,
 	subscribeCredentialToMeshService,
 } = require('../../lib/devConsole');
 
-require('dotenv').config();
-
 const { MULTITENANT_GRAPHQL_SERVER_BASE_URL } = CONSTANTS;
 
 class CreateCommand extends Command {
@@ -32,6 +38,7 @@ class CreateCommand extends Command {
 		ignoreCache: ignoreCacheFlag,
 		autoConfirmAction: autoConfirmActionFlag,
 		json: jsonFlag,
+		env: envFileFlag,
 	};
 
 	static enableJsonFlag = true;
@@ -51,22 +58,47 @@ class CreateCommand extends Command {
 
 		const ignoreCache = await flags.ignoreCache;
 		const autoConfirmAction = await flags.autoConfirmAction;
-
+		const envFilePath = await flags.env;
 		const { imsOrgId, projectId, workspaceId } = await initSdk({
 			ignoreCache,
 		});
 
+		//Input the mesh data from the 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);
+				this.error('Input mesh file is not a valid JSON. Please check the file provided.');
+			}
+		}
+
+		let filesList = [];
+
 		try {
-			data = JSON.parse(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.',
-			);
+			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 = 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. Please check the file and try again.',
+				);
+			}
 		}
 
 		let shouldContinue = true;
@@ -78,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/init.js

@@ -0,0 +1,168 @@
+/*
+Copyright 2021 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const { Command, Flags } = require('@oclif/core');
+const resolve = require('path').resolve;
+
+const { promptConfirm, promptSelect, runCliCommand } = require('../../helpers');
+const { getAppRootDir } = require('../../utils');
+
+const fs = require('fs/promises');
+
+class InitCommand extends Command {
+	static summary = 'Initiate API Mesh workspace';
+	static description =
+		'This command will create a workspace where you can organise your API mesh configuration and other files';
+
+	static args = [
+		{
+			name: 'projectName',
+			required: true,
+			description: 'Project name',
+		},
+	];
+
+	static flags = {
+		path: Flags.string({
+			char: 'p',
+			summary: 'workspace path',
+			default: '.',
+		}),
+		packageManager: Flags.string({
+			char: 'm',
+			summary: 'select yarn or npm for package management',
+			options: ['npm', 'yarn'],
+		}),
+		git: Flags.string({
+			char: 'g',
+			summary: 'Should the workspace be initiated as a git project.',
+			options: ['y', 'n'],
+		}),
+	};
+
+	static enableJsonFlag = true;
+
+	static examples = [
+		{
+			description: 'API mesh workspace init',
+			command: 'aio api-mesh init commerce-mesh',
+		},
+		{
+			description: 'API mesh workspace init with flags',
+			command:
+				'aio api-mesh init commerce-mesh --path ./mesh_projects/test_mesh --git y --packageManager yarn',
+		},
+	];
+
+	async createPackageJson(templatePath, filePath, projectTitle = 'api-mesh-starter') {
+		const template = await fs.readFile(templatePath, 'utf8');
+
+		const pkgJSON = { ...JSON.parse(template), name: projectTitle };
+
+		await fs.writeFile(filePath, JSON.stringify(pkgJSON, null, 2), 'utf8', { mode: 'w' });
+	}
+
+	async run() {
+		const { args, flags } = await this.parse(InitCommand);
+		const gitFlagOptions = {
+			y: true,
+			n: false,
+		};
+
+		let absolutePath = resolve(flags.path);
+		let shouldCreateGit = gitFlagOptions[flags.git];
+		let packageManagerChoice = flags.packageManager;
+		const packageJsonTemplate = `${getAppRootDir()}/src/templates/package.json`;
+		const shouldCreateWorkspace = await promptConfirm(
+			`Do you want to create the workspace in ${absolutePath}`,
+		);
+
+		if (shouldCreateWorkspace) {
+			if (shouldCreateGit === undefined) {
+				shouldCreateGit = await promptConfirm(`Do you want to initiate git in your workspace?`);
+			}
+
+			if (packageManagerChoice === undefined) {
+				packageManagerChoice = await promptSelect(`Select a package manager`, [
+					{ name: 'npm', value: 'npm' },
+					{ name: 'yarn', value: 'yarn' },
+				]);
+			}
+
+			try {
+				await fs.access(absolutePath);
+				if (
+					!(await promptConfirm(
+						'The directory is not empty. Do you want to create a sub directory with project name',
+					))
+				) {
+					return;
+				}
+				absolutePath += '/' + args.projectName;
+			} catch (err) {
+				// No action needed
+			}
+
+			this.log(`Creating workspace in ${absolutePath}`);
+
+			try {
+				await fs.mkdir(absolutePath);
+			} catch (error) {
+				this.error(`Could not create directory ${error.message}`);
+			}
+
+			if (shouldCreateGit) {
+				this.log('Initiating git in workspace');
+				try {
+					await runCliCommand('git init', absolutePath);
+
+					const gitIgnoreTemplate = `${getAppRootDir()}/src/templates/gitignore`;
+
+					await fs.writeFile(`${absolutePath}/.gitignore`, gitIgnoreTemplate, 'utf8', {
+						mode: 'w',
+					});
+				} catch (error) {
+					this.error(error);
+				}
+			}
+
+			await fs.writeFile(`${absolutePath}/.env`, '', 'utf8', { mode: 'w' });
+
+			this.log(`Installing dependencies`);
+
+			await this.createPackageJson(
+				packageJsonTemplate,
+				`${absolutePath}/package.json`,
+				args.projectName,
+			);
+
+			if (packageManagerChoice === 'npm') {
+				try {
+					await runCliCommand(`npm install`, absolutePath);
+				} catch (error) {
+					this.error(error);
+				}
+			}
+
+			if (packageManagerChoice === 'yarn') {
+				try {
+					await runCliCommand(`yarn install`, absolutePath);
+				} catch (error) {
+					this.error(error);
+				}
+			}
+
+			this.log('workspace setup done successfully');
+		}
+	}
+}
+
+module.exports = InitCommand;

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

@@ -10,20 +10,26 @@ governing permissions and limitations under the License.
 */
 
 const { Command } = require('@oclif/command');
-const { readFile } = require('fs/promises');
 
 const logger = require('../../classes/logger');
-const { initSdk, initRequestId, promptConfirm } = require('../../helpers');
-const { ignoreCacheFlag, autoConfirmActionFlag } = require('../../utils');
+const { initSdk, initRequestId, promptConfirm, importFiles } = require('../../helpers');
+const {
+	ignoreCacheFlag,
+	autoConfirmActionFlag,
+	envFileFlag,
+	checkPlaceholders,
+	readFileContents,
+	validateAndInterpolateMesh,
+	getFilesInMeshConfig,
+} = require('../../utils');
 const { getMeshId, updateMesh } = require('../../lib/devConsole');
 
-require('dotenv').config();
-
 class UpdateCommand extends Command {
 	static args = [{ name: 'file' }];
 	static flags = {
 		ignoreCache: ignoreCacheFlag,
 		autoConfirmAction: autoConfirmActionFlag,
+		env: envFileFlag,
 	};
 
 	async run() {
@@ -41,23 +47,14 @@ class UpdateCommand extends Command {
 
 		const ignoreCache = await flags.ignoreCache;
 		const autoConfirmAction = await flags.autoConfirmAction;
+		const envFilePath = await flags.env;
 
 		const { imsOrgId, projectId, workspaceId } = await initSdk({
 			ignoreCache,
 		});
 
-		let data;
-
-		try {
-			data = JSON.parse(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.',
-			);
-		}
+		//Input the mesh data from the input file
+		let inputMeshData = await readFileContents(args.file, this, 'mesh');
 
 		let meshId = null;
 
@@ -69,6 +66,41 @@ class UpdateCommand extends Command {
 			);
 		}
 
+		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);
+				this.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);
+			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 = 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. Please check the file and try again.',
+				);
+			}
+		}
+
 		if (meshId) {
 			let shouldContinue = true;
 

package/src/helpers.js

@@ -12,7 +12,6 @@ governing permissions and limitations under the License.
 
 const fs = require('fs');
 const inquirer = require('inquirer');
-
 const Config = require('@adobe/aio-lib-core-config');
 const { getToken, context } = require('@adobe/aio-lib-ims');
 const { CLI } = require('@adobe/aio-lib-ims/src/context');
@@ -22,10 +21,48 @@ const { getCliEnv } = require('@adobe/aio-lib-env');
 const logger = require('../src/classes/logger');
 const { UUID } = require('./classes/UUID');
 const CONSTANTS = require('./constants');
-const { objToString } = require('./utils');
+const path = require('path');
+const { exec } = require('child_process');
+const { stdout, stderr } = require('process');
+const jsmin = require('jsmin').jsmin;
 
 const { DEV_CONSOLE_BASE_URL, DEV_CONSOLE_API_KEY, AIO_CLI_API_KEY } = CONSTANTS;
 
+/**
+ * Returns the string representation of the object's path.
+ * If the path evaluates to false, the default string is returned.
+ *
+ * @param {object} obj
+ * @param {Array<string>} path
+ * @param {string} defaultString
+ * @returns {string}
+ */
+function objToString(obj, path = [], defaultString = '') {
+	try {
+		// Cache the current object
+		let current = obj;
+
+		// For each item in the path, dig into the object
+		for (let i = 0; i < path.length; i++) {
+			// If the item isn't found, return the default (or null)
+			if (!current[path[i]]) return defaultString;
+
+			// Otherwise, update the current  value
+			current = current[path[i]];
+		}
+
+		if (typeof current === 'string') {
+			return current;
+		} else if (typeof current === 'object') {
+			return JSON.stringify(current, null, 2);
+		} else {
+			return defaultString;
+		}
+	} catch (error) {
+		return defaultString;
+	}
+}
+
 /**
  * @param configFilePath
  */
@@ -311,7 +348,7 @@ const selectWorkspace = async (orgId, projectId, imsOrgTitle, projectTitle) => {
 			throw new Error('No workspace selected');
 		}
 	} else {
-		this.error(
+		throw new Error(
 			'No workspaces found for the selected organization: ' +
 				imsOrgTitle +
 				' and project: ' +
@@ -459,7 +496,217 @@ async function promptInput(message) {
 	return selected.item;
 }
 
+/**
+ * Import the files in the files array in meshConfig
+ *
+ * @param data 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
+ */
+async function importFiles(data, filesListArray, meshConfigName, autoConfirmActionFlag) {
+	//if autoConfirmActionFlag is passed in the command, it should override by default
+	let shouldOverride = true;
+	let filesNotFound = [];
+	let filesPathMap = new Map();
+	let filesListMap = new Map(
+		filesListArray.map(ele => {
+			return [ele];
+		}),
+	);
+
+	//copy the meshConfig data
+	let resultData = data;
+
+	//array of {file to be overridden, overrideIndex}
+	let overrideArr = [];
+
+	if (data.meshConfig.files) {
+		for (let i = 0; i < data.meshConfig.files?.length; i++) {
+			filesPathMap.set(data.meshConfig.files[i].path, i);
+		}
+	}
+
+	for (let file of filesListMap.keys()) {
+		//if file exists in files array
+		if (filesPathMap.has(file)) {
+			//if file exists in files array, then override
+			if (fs.existsSync(path.resolve(path.dirname(meshConfigName), file))) {
+				if (!autoConfirmActionFlag) {
+					let index = filesPathMap.get(file);
+					overrideArr.push({ fileName: file, index: index });
+				}
+			}
+		} else {
+			//if file does not exist in files array, but exists in filesystem, we append
+			if (fs.existsSync(path.resolve(path.dirname(meshConfigName), file))) {
+				resultData = updateFilesArray(resultData, file, meshConfigName, -1);
+			} else {
+				filesNotFound.push(file);
+			}
+		}
+	}
+
+	if (filesNotFound.length) {
+		for (let i = 0; i < filesNotFound.length; i++) {
+			filesNotFound[i] = path.basename(filesNotFound[i]);
+		}
+
+		throw new Error(
+			`Please make sure the file(s): ${filesNotFound.join(', ')} and ${path.basename(
+				meshConfigName,
+			)} are in the same directory/subdirectory`,
+		);
+	}
+
+	for (let i = 0; i < overrideArr.length; i++) {
+		shouldOverride = await promptConfirm(
+			`Do you want to override the ${path.basename(overrideArr[i].fileName)} file?`,
+		);
+
+		if (shouldOverride) {
+			resultData = updateFilesArray(
+				resultData,
+				overrideArr[i].fileName,
+				meshConfigName,
+				overrideArr[i].index,
+			);
+		}
+	}
+
+	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} having interpolationStatus, missingKeys and interpolatedMesh
+ */
+
+async function interpolateMesh(data, obj) {
+	let missingKeys = new Set();
+	let interpolatedMesh;
+	let pupa;
+	try {
+		pupa = (await import('pupa')).default;
+	} catch {
+		throw new Error('Error while loading pupa module');
+	}
+
+	interpolatedMesh = pupa(data, obj, {
+		ignoreMissing: true,
+		transform: ({ value, key }) => {
+			if (key.startsWith('env.')) {
+				if (value) {
+					return value;
+				} else {
+					// missing value, add to list
+					missingKeys.add(key.split('.')[1]);
+				}
+			} else {
+				//ignore
+				return undefined;
+			}
+			return value;
+		},
+	});
+
+	if (missingKeys.size) {
+		return {
+			interpolationStatus: 'failed',
+			missingKeys: Array.from(missingKeys),
+			interpolatedMesh: '',
+		};
+	}
+	return {
+		interpolationStatus: 'success',
+		missingKeys: [],
+		interpolatedMeshData: interpolatedMesh,
+	};
+}
+
+/** Function to run cli command
+ *
+ * @param command Ocliff/Command
+ * @param workingDirectory string
+ *
+ * @returns Promise<void>
+ */
+function runCliCommand(command, workingDirectory = '.') {
+	return new Promise((resolve, reject) => {
+		const childProcess = exec(command, { cwd: workingDirectory });
+		childProcess.stdout.pipe(stdout);
+		childProcess.stdin.pipe(stderr);
+		childProcess.on('exit', code => {
+			if (code === 0) {
+				resolve();
+			} else {
+				reject(new Error(`${command} exection failed`));
+			}
+		});
+	});
+}
+
+/**
+ * Append/override files to the files array in meshConfig
+ *
+ * @param data MeshConfig
+ * @param file File to append or override
+ * @param meshConfigName MeshConfig name
+ * @param index Append operation if index is -1, else override, it is the index where the override takes place
+ */
+function updateFilesArray(data, file, meshConfigName, index) {
+	try {
+		let readFileData = fs.readFileSync(
+			path.resolve(path.dirname(meshConfigName), file),
+			{ encoding: 'utf-8' },
+			err => {
+				if (err) {
+					throw new Error(err);
+				}
+			},
+		);
+
+		try {
+			//validate JSON file
+			if (path.extname(file) === '.json') {
+				readFileData = JSON.stringify(JSON.parse(readFileData));
+			}
+		} catch (err) {
+			logger.error(err.message);
+			throw new Error(`Invalid JSON content in ${path.basename(file)}`);
+		}
+
+		//data to be overridden or appended
+		const dataInFilesArray = jsmin(readFileData);
+
+		if (index >= 0) {
+			data.meshConfig.files[index] = {
+				path: file,
+				content: dataInFilesArray,
+			};
+		} else {
+			//if the files array does not exist
+			if (!data.meshConfig.files) {
+				data.meshConfig.files = [];
+			}
+
+			//if the files arrray exists, we append the file path and content in meshConfig
+			data.meshConfig.files.push({
+				path: file,
+				content: dataInFilesArray,
+			});
+		}
+
+		return data;
+	} catch (err) {
+		logger.error(err.message);
+		throw new Error(err.message);
+	}
+}
+
 module.exports = {
+	objToString,
 	promptInput,
 	promptConfirm,
 	getLibConsoleCLI,
@@ -468,4 +715,8 @@ module.exports = {
 	initRequestId,
 	promptSelect,
 	promptMultiselect,
+	importFiles,
+	interpolateMesh,
+	runCliCommand,
+	updateFilesArray,
 };

package/src/lib/devConsole.js

@@ -4,12 +4,11 @@
 const axios = require('axios');
 
 const logger = require('../classes/logger');
-const { objToString } = require('../utils');
 const CONSTANTS = require('../constants');
 
 const { DEV_CONSOLE_TRANSPORTER_API_KEY } = CONSTANTS;
 
-const { getDevConsoleConfig } = require('../helpers');
+const { objToString, getDevConsoleConfig } = require('../helpers');
 
 const getApiKeyCredential = async (organizationId, projectId, workspaceId) => {
 	const { baseUrl: devConsoleUrl, accessToken } = await getDevConsoleConfig();

package/src/templates/gitignore

@@ -0,0 +1 @@
+node_modules