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

package/src/templates/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "",
+	"version": "0.0.1",
+	"publishConfig": {
+		"access": "public"
+	},
+	"dependencies": {
+		"@graphql-mesh/cli": "^0.78.33",
+		"@graphql-mesh/graphql": "^0.32.4",
+		"@graphql-mesh/json-schema": "^0.35.28",
+		"@graphql-mesh/openapi": "^0.33.39",
+		"@graphql-mesh/plugin-http-details-extensions": "^0.0.12",
+		"@graphql-mesh/runtime": "^0.44.37",
+		"@graphql-mesh/transform-encapsulate": "^0.3.114",
+		"@graphql-mesh/transform-federation": "^0.9.60",
+		"@graphql-mesh/transform-filter-schema": "^0.14.113",
+		"@graphql-mesh/transform-hoist-field": "^0.1.78",
+		"@graphql-mesh/transform-naming-convention": "^0.12.3",
+		"@graphql-mesh/transform-prefix": "^0.11.104",
+		"@graphql-mesh/transform-prune": "^0.0.88",
+		"@graphql-mesh/transform-rename": "^0.13.2",
+		"@graphql-mesh/transform-replace-field": "^0.3.112",
+		"@graphql-mesh/transform-resolvers-composition": "^0.12.111",
+		"@graphql-mesh/transform-type-merging": "^0.4.56",
+		"@graphql-mesh/types": "^0.87.1",
+		"graphql": "^16.6.0"
+	},
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"keywords": [
+		"api-mesh"
+	],
+	"license": "Apache-2.0",
+	"scripts": {},
+	"description": "API mesh starter template",
+	"author": "Adobe Inc."
+}

package/src/utils.js

@@ -1,40 +1,22 @@
+const fs = require('fs');
+const path = require('path');
+const logger = require('../src/classes/logger');
+const { Flags } = require('@oclif/core');
+const { readFile } = require('fs/promises');
+const { interpolateMesh } = require('./helpers');
+const dotenv = require('dotenv');
+
 /**
- * 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}
+ * @returns returns the root directory of the project
  */
-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;
+function getAppRootDir() {
+	let currentDir = __dirname;
+	while (!fs.existsSync(path.join(currentDir, 'package.json'))) {
+		currentDir = path.join(currentDir, '..');
 	}
+	return currentDir;
 }
 
-const { Flags } = require('@oclif/core');
-
 const ignoreCacheFlag = Flags.boolean({
 	char: 'i',
 	description: 'Ignore cache and force manual org -> project -> workspace selection',
@@ -53,9 +35,331 @@ const jsonFlag = Flags.boolean({
 	default: false,
 });
 
+const envFileFlag = Flags.string({
+	char: 'e',
+	description: 'Path to env file',
+	default: '.env',
+});
+
+/**
+ * Parse the meshConfig and get the list of (local) files to be imported
+ *
+ * @param data MeshConfig
+ * @param meshConfigName MeshConfig
+ * @returns files[] files present in meshConfig
+ */
+function getFilesInMeshConfig(data, meshConfigName) {
+	//ignore if the file names start with http or https
+	const fileURLRegex = /^(http|s:\/\/)/;
+
+	let filesList = [];
+
+	data.meshConfig.sources.forEach(source => {
+		// JSONSchema handler
+		source.handler.JsonSchema?.operations.forEach(operation => {
+			if (operation.requestSchema && !fileURLRegex.test(operation.requestSchema)) {
+				filesList.push(operation.requestSchema);
+			}
+			if (operation.responseSchema && !fileURLRegex.test(operation.responseSchema)) {
+				filesList.push(operation.responseSchema);
+			}
+			if (operation.requestSample && !fileURLRegex.test(operation.requestSample)) {
+				filesList.push(operation.requestSample);
+			}
+			if (operation.responseSample && !fileURLRegex.test(operation.responseSample)) {
+				filesList.push(operation.responseSample);
+			}
+		});
+
+		// OpenAPI handler
+		if (source.handler.openapi && !fileURLRegex.test(source.handler.openapi.source)) {
+			filesList.push(source.handler.openapi.source);
+		}
+	});
+
+	// Additional Resolvers
+	data.meshConfig.additionalResolvers?.forEach(additionalResolver => {
+		if (!fileURLRegex.test(additionalResolver)) {
+			filesList.push(additionalResolver);
+		}
+	});
+
+	// ReplaceField Transform - source level
+	data.meshConfig.sources.transforms?.forEach(transform => {
+		transform.replaceField?.replacements.forEach(replacement => {
+			if (replacement.composer && !fileURLRegex.test(replacement.composer)) {
+				filesList.push(replacement.composer);
+			}
+		});
+	});
+
+	// ReplaceField Transform - mesh level
+	data.meshConfig.transforms?.forEach(transform => {
+		transform.replaceField?.replacements.forEach(replacement => {
+			if (replacement.composer && !fileURLRegex.test(replacement.composer)) {
+				filesList.push(replacement.composer);
+			}
+		});
+	});
+
+	try {
+		if (filesList.length) {
+			checkFilesAreUnderMeshDirectory(filesList, meshConfigName);
+			validateFileType(filesList);
+			validateFileName(filesList, data);
+		}
+	} catch (err) {
+		logger.error(err.message);
+		throw new Error(err.message);
+	}
+
+	return filesList;
+}
+
+/**
+ * Checks if files are in the same directory or subdirectories of mesh
+ *
+ * @param data MeshConfig
+ * @param meshConfigName MeshConfig
+ */
+function checkFilesAreUnderMeshDirectory(filesList, meshConfigName) {
+	//handle files that are outside to the directory and subdirectories of meshConfig
+	let invalidPaths = [];
+	for (let i = 0; i < filesList.length; i++) {
+		if (
+			!path
+				.resolve(path.dirname(meshConfigName), filesList[i])
+				.includes(path.resolve(path.dirname(meshConfigName))) ||
+			filesList[i].includes('~')
+		) {
+			invalidPaths.push(path.basename(filesList[i]));
+		}
+	}
+
+	filesOutsideRootDir(invalidPaths);
+}
+
+/**
+ * Error out if the files are outside the mesh directory
+ *
+ * @param invalidPaths Array
+ */
+function filesOutsideRootDir(invalidPaths) {
+	if (invalidPaths.length) {
+		throw new Error(`File(s): ${invalidPaths.join(', ')} is outside the mesh directory.`);
+	}
+}
+
+/**
+ * Check if there are any placeholders in the input mesh file
+ * The below regular expressions are part of pupa string interpolation
+ * doubleBraceRegex = /{{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}}/gi
+ * braceRegex = /{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}/gi
+ * The above regex has been enhanced to include prefix '.env'
+ * @param {string} mesh
+ * @returns {boolean}
+ */
+
+function checkPlaceholders(mesh) {
+	const doubleBraceRegex = /{{env\.(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}}/gi;
+	const braceRegex = /{env\.(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}/gi;
+	const foundDoubleBraceRegex = mesh.match(doubleBraceRegex);
+	const foundSingleBraceRegex = mesh.match(braceRegex);
+
+	if (
+		typeof foundDoubleBraceRegex === 'object' &&
+		foundDoubleBraceRegex === null &&
+		typeof foundSingleBraceRegex === 'object' &&
+		foundSingleBraceRegex === null
+	) {
+		return false;
+	}
+	return true;
+}
+
+/**
+ * Read the file contents. If there is any error, report it to the user.
+ * @param {string} file
+ * @param {object} command
+ * @param {string} filetype
+ * @returns {string}
+ */
+async function readFileContents(file, command, filetype) {
+	try {
+		return await readFile(file, 'utf8');
+	} catch (error) {
+		command.log(error.message);
+		if (filetype === 'mesh') {
+			command.error(
+				`Unable to read the mesh configuration file provided. Please check the file and try again.`,
+			);
+		}
+		command.error(`Unable to read the file ${file}. Please check the file and try again.`);
+	}
+}
+
+/**
+ * Check if the files are of valid types .js, .json
+ *
+ * @param filesList List of files in mesh config
+ */
+function validateFileType(filesList) {
+	const filesWithInvalidTypes = [];
+
+	filesList.forEach(file => {
+		const extension = path.extname(file);
+		const isValidFileType = ['.js', '.json'].includes(extension);
+
+		if (!isValidFileType) {
+			filesWithInvalidTypes.push(path.basename(file));
+		}
+	});
+
+	if (filesWithInvalidTypes.length) {
+		throw new Error(
+			`Mesh files must be JavaScript or JSON. Other file types are not supported. The following file(s) are invalid: ${filesWithInvalidTypes}.`,
+		);
+	}
+}
+
+/**
+ * Validate the filenames
+ *
+ * @param filesList Files in sources, tranforms or additionalResolvers in the meshConfig
+ * @param data MeshConfig
+ */
+function validateFileName(filesList, data) {
+	const filesWithInvalidNames = [];
+
+	// Check if the file names are less than 25 characters
+	filesList.forEach(file => {
+		const fileName = path.basename(file);
+		if (fileName.length > 25) {
+			filesWithInvalidNames.push(fileName);
+		}
+	});
+
+	if (filesWithInvalidNames.length) {
+		throw new Error(
+			`Mesh file names must be less than 25 characters. The following file(s) are invalid: ${filesWithInvalidNames}.`,
+		);
+	}
+
+	// check if the the filePaths in the files array match
+	// the fileNames in sources, transforms or additionalResolvers
+
+	if (data.meshConfig.files) {
+		for (let i = 0; i < data.meshConfig.files.length; i++) {
+			if (filesList.indexOf(data.meshConfig.files[i].path) == -1) {
+				throw new Error(`Please make sure the file names are matching in meshConfig.`);
+			}
+		}
+	}
+}
+
+/**validates the environment file content
+ * @param {string} envContent
+ * @returns {object} containing the status of validation
+ * If validation is failed then the error property including the formatting errors is returned.
+ */
+function validateEnvFileFormat(envContent) {
+	//Key should start with a underscore or an alphabet followed by underscore/alphanumeric characters
+	const envKeyRegex = /^[a-zA-Z_]+[a-zA-Z0-9_]*$/;
+
+	const envValueRegex = /^(?:"(?:\\.|[^\\"])*"|'(?:\\.|[^\\'])*'|[^'"\s])+$/;
+
+	/*
+	The above regex matches one or more of below :
+	(?:"(?:\\.|[^\\"])*"|'(?:\\.|[^\\'])*'|[^'"\s])
+	which is 
+	1. ?:"(?:\\.|[^\\"])*" : Non capturing group starts and ends with '"'
+	*/
+	const envDict = {};
+	const lines = envContent.split(/\r?\n/);
+	const errors = [];
+
+	for (let index = 0; index < lines.length; index++) {
+		const line = lines[index];
+		const trimmedLine = line.trim();
+		if (trimmedLine.startsWith('#') || trimmedLine === '') {
+			// ignore comment or empty lines
+			continue;
+		}
+
+		if (!trimmedLine.includes('=')) {
+			errors.push(`Invalid format << ${trimmedLine} >> on line ${index + 1}`);
+		} else {
+			const [key, value] = trimmedLine.split('=', 2);
+			if (!envKeyRegex.test(key) || !envValueRegex.test(value)) {
+				// invalid format: key or value does not match regex
+				errors.push(`Invalid format for key/value << ${trimmedLine} >> on line ${index + 1}`);
+			}
+			if (key in envDict) {
+				// duplicate key found
+				errors.push(`Duplicate key << ${key} >> on line ${index + 1}`);
+			}
+			envDict[key] = value;
+		}
+	}
+	if (errors.length) {
+		return {
+			valid: false,
+			error: errors.toString(),
+		};
+	}
+	return {
+		valid: true,
+	};
+}
+
+/**
+ * Read the environment file, checks for validation status and interpolate mesh
+ * @param {string} inputMeshData
+ * @param {string} envFilePath
+ * @param {object} command
+ * @returns {string}
+ */
+async function validateAndInterpolateMesh(inputMeshData, envFilePath, command) {
+	//Read the environment file
+	const envFileContent = await readFileContents(envFilePath, command, 'env');
+
+	//Validate the environment file
+	const envFileValidity = validateEnvFileFormat(envFileContent);
+	if (envFileValidity.valid) {
+		//load env file using dotenv and add 'env' as the root property in the object
+		const envObj = { env: dotenv.config({ path: envFilePath }).parsed };
+		const { interpolationStatus, missingKeys, interpolatedMeshData } = await interpolateMesh(
+			inputMeshData,
+			envObj,
+		);
+
+		if (interpolationStatus == 'failed') {
+			command.error(
+				'The mesh file cannot be interpolated due to missing keys : ' + missingKeys.join(' , '),
+			);
+		}
+
+		try {
+			return JSON.parse(interpolatedMeshData);
+		} catch (err) {
+			command.log(err.message);
+			command.log(interpolatedMeshData);
+			command.error('Interpolated mesh is not a valid JSON. Please check the generated json file.');
+		}
+	} else {
+		command.error(`Issue in ${envFilePath} file - ` + envFileValidity.error);
+	}
+}
+
 module.exports = {
-	objToString,
 	ignoreCacheFlag,
 	autoConfirmActionFlag,
 	jsonFlag,
+	getFilesInMeshConfig,
+	envFileFlag,
+	checkPlaceholders,
+	readFileContents,
+	validateEnvFileFormat,
+	validateAndInterpolateMesh,
+	getAppRootDir,
 };