@adobe/aio-cli-plugin-api-mesh 3.0.1 → 3.1.0-beta.2

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

@@ -70,6 +70,18 @@ class InitCommand extends Command {
 		await fs.writeFile(filePath, JSON.stringify(pkgJSON, null, 2), 'utf8', { mode: 'w' });
 	}
 
+	async createDotNpmrcFile(templatePath, filePath) {
+		const dotNpmrcFile = await fs.readFile(templatePath, 'utf8');
+
+		await fs.writeFile(filePath, dotNpmrcFile, 'utf8', { mode: 'w' });
+	}
+
+	async createGitIgnoreFile(templatePath, filePath) {
+		const gitIgnoreFile = await fs.readFile(templatePath, 'utf8');
+
+		await fs.writeFile(filePath, gitIgnoreFile, 'utf8', { mode: 'w' });
+	}
+
 	async run() {
 		const { args, flags } = await this.parse(InitCommand);
 		const gitFlagOptions = {
@@ -81,6 +93,7 @@ class InitCommand extends Command {
 		let shouldCreateGit = gitFlagOptions[flags.git];
 		let packageManagerChoice = flags.packageManager;
 		const packageJsonTemplate = `${getAppRootDir()}/src/templates/package.json`;
+		const dotNpmrcPath = `${getAppRootDir()}/src/templates/npmrc`;
 		const shouldCreateWorkspace = await promptConfirm(
 			`Do you want to create the workspace in ${absolutePath}`,
 		);
@@ -124,11 +137,10 @@ class InitCommand extends Command {
 				try {
 					await runCliCommand('git init', absolutePath);
 
-					const gitIgnoreTemplate = `${getAppRootDir()}/src/templates/gitignore`;
+					const gitIgnoreTemplatePath = `${getAppRootDir()}/src/templates/gitignore`;
+					const gitIgnoreFilePath = `${absolutePath}/.gitignore`;
 
-					await fs.writeFile(`${absolutePath}/.gitignore`, gitIgnoreTemplate, 'utf8', {
-						mode: 'w',
-					});
+					await this.createGitIgnoreFile(gitIgnoreTemplatePath, gitIgnoreFilePath);
 				} catch (error) {
 					this.error(error);
 				}
@@ -144,6 +156,8 @@ class InitCommand extends Command {
 				args.projectName,
 			);
 
+			await this.createDotNpmrcFile(dotNpmrcPath, `${absolutePath}/.npmrc`);
+
 			if (packageManagerChoice === 'npm') {
 				try {
 					await runCliCommand(`npm install`, absolutePath);

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

@@ -0,0 +1,156 @@
+/*
+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 } = require('@oclif/core');
+const {
+	portNoFlag,
+	debugFlag,
+	envFileFlag,
+	autoConfirmActionFlag,
+	readFileContents,
+	validateAndInterpolateMesh,
+	checkPlaceholders,
+	getFilesInMeshConfig,
+} = require('../../utils');
+const meshBuilder = require('@adobe-apimesh/mesh-builder');
+const fs = require('fs');
+const UUID = require('../../uuid');
+const path = require('path');
+const { initRequestId, startGraphqlServer, importFiles } = require('../../helpers');
+const logger = require('../../classes/logger');
+require('dotenv').config();
+
+const { validateMesh, buildMesh, compileMesh } = meshBuilder.default;
+
+class RunCommand extends Command {
+	static summary = 'Run local development server';
+	static description = 'Run a local development server that builds and compiles a mesh locally';
+
+	static args = [
+		{
+			name: 'file',
+			description: 'Mesh File',
+		},
+	];
+
+	static flags = {
+		port: portNoFlag,
+		debug: debugFlag,
+		env: envFileFlag,
+		autoConfirmAction: autoConfirmActionFlag,
+	};
+
+	static enableJsonFlag = true;
+
+	static examples = [];
+
+	async run() {
+		await initRequestId();
+
+		logger.info(`RequestId: ${global.requestId}`);
+
+		const { args, flags } = await this.parse(RunCommand);
+
+		if (!args.file) {
+			throw new Error('Missing file path. Run aio api-mesh run --help for more info.');
+		}
+
+		let portNo;
+
+		//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;
+		}
+
+		const envFilePath = await flags.env;
+
+		try {
+			//Ensure that current directory includes package.json
+			if (fs.existsSync(path.join(process.cwd(), 'package.json'))) {
+				//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
+				let meshId = UUID.newUuid().toString();
+
+				await validateMesh(data.meshConfig);
+				await buildMesh(meshId, data.meshConfig);
+				await compileMesh(meshId);
+
+				this.log(`Starting server on port : ${portNo}`);
+				await startGraphqlServer(meshId, portNo, flags.debug);
+			} else {
+				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.',
+				);
+			}
+		} catch (error) {
+			this.error(error.message);
+		}
+	}
+}
+
+module.exports = RunCommand;

package/src/helpers.js

@@ -522,7 +522,13 @@ async function promptInput(message) {
  * @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) {
+async function importFiles(
+	data,
+	filesListArray,
+	meshConfigName,
+	autoConfirmActionFlag,
+	shouldMinifyJS = true,
+) {
 	//if autoConfirmActionFlag is passed in the command, it should override by default
 	let shouldOverride = true;
 	let filesNotFound = [];
@@ -558,7 +564,7 @@ async function importFiles(data, filesListArray, meshConfigName, autoConfirmActi
 		} 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);
+				resultData = updateFilesArray(resultData, file, meshConfigName, -1, shouldMinifyJS);
 			} else {
 				filesNotFound.push(file);
 			}
@@ -588,6 +594,7 @@ async function importFiles(data, filesListArray, meshConfigName, autoConfirmActi
 				overrideArr[i].fileName,
 				meshConfigName,
 				overrideArr[i].index,
+				shouldMinifyJS,
 			);
 		}
 	}
@@ -673,7 +680,7 @@ function runCliCommand(command, workingDirectory = '.') {
  * @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) {
+function updateFilesArray(data, file, meshConfigName, index, shouldMinifyJS = true) {
 	try {
 		let readFileData = fs.readFileSync(
 			path.resolve(path.dirname(meshConfigName), file),
@@ -695,8 +702,17 @@ function updateFilesArray(data, file, meshConfigName, index) {
 			throw new Error(`Invalid JSON content in ${path.basename(file)}`);
 		}
 
-		//data to be overridden or appended
-		const dataInFilesArray = jsmin(readFileData);
+		// shouldMinifyJS would be always true for create and update commands
+		// if run command run on debug mode it will be false and js files wont be minified
+		if (shouldMinifyJS) {
+			readFileData = jsmin(readFileData);
+		} else {
+			if (path.extname(file) !== '.js') {
+				readFileData = jsmin(readFileData);
+			}
+		}
+
+		const dataInFilesArray = readFileData;
 
 		if (index >= 0) {
 			data.meshConfig.files[index] = {
@@ -723,6 +739,42 @@ function updateFilesArray(data, file, meshConfigName, index) {
 	}
 }
 
+/**
+ * Start GraphQL server for a particular mesh on a particular port
+ *
+ * @param meshId MeshId of the mesh
+ * @param port Port number at which the server is to be started
+ * @param debug Boolean flag to set the debug mode
+ */
+function startGraphqlServer(meshId, port, debug) {
+	const serverPath = `${__dirname}/server.js ${meshId} ${port}`;
+	const command = debug
+		? `node --inspect-brk --trace-warnings ${serverPath}`
+		: `node ${serverPath}`;
+
+	const server = exec(command);
+
+	server.stdout.on('data', data => {
+		console.log(data);
+	});
+
+	server.stderr.on('data', data => {
+		console.error(data);
+	});
+
+	server.on('close', code => {
+		console.log(`Server closed with code ${code}`);
+	});
+
+	server.on('exit', code => {
+		console.log(`Server exited with code ${code}`);
+	});
+
+	server.on('error', err => {
+		console.error(`Server exited with error ${err}`);
+	});
+}
+
 module.exports = {
 	objToString,
 	promptInput,
@@ -737,4 +789,5 @@ module.exports = {
 	interpolateMesh,
 	runCliCommand,
 	updateFilesArray,
+	startGraphqlServer,
 };

package/src/server.js

@@ -0,0 +1,168 @@
+// Resolve the path to 'fastify' and 'graphql-yoga' within the local 'node_modules'
+const fastifyPath = require.resolve('fastify', { paths: [process.cwd()] });
+const yogaPath = require.resolve('graphql-yoga', { paths: [process.cwd()] });
+
+// Load 'fastify' and 'graphql-yoga' using the resolved paths
+const fastify = require(fastifyPath);
+const { createYoga } = require(yogaPath);
+const logger = require('./classes/logger');
+
+//Load the functions from serverUtils.js
+const {
+	readMeshConfig,
+	removeRequestHeaders,
+	prepSourceResponseHeaders,
+	processResponseHeaders,
+} = require('./serverUtils');
+
+let yogaServer = null;
+let meshConfig;
+
+// catch unhandled promise rejections
+process.on('unhandledRejection', reason => {
+	logger.error('Unhandled Rejection at:', reason.stack || reason);
+});
+
+// catch uncaught exceptions
+process.on('uncaughtException', err => {
+	logger.error('Uncaught Exception thrown');
+	logger.error(err.stack);
+	process.exit(1);
+});
+
+// get meshId from command line arguments
+const meshId = process.argv[2];
+
+// get PORT number from command line arguments
+const portNo = parseInt(process.argv[3]);
+
+const getCORSOptions = () => {
+	try {
+		const currentWorkingDirectory = process.cwd();
+		const meshConfigPath = `${currentWorkingDirectory}/mesh-artifact/${meshId}/.meshrc.json`;
+
+		const meshConfig = require(meshConfigPath);
+		const { responseConfig } = meshConfig;
+		const { CORS } = responseConfig;
+
+		return CORS;
+	} catch (e) {
+		return {};
+	}
+};
+
+const getYogaServer = async () => {
+	if (yogaServer) {
+		return yogaServer;
+	} else {
+		const currentWorkingDirectory = process.cwd();
+		const meshArtifactsPath = `${currentWorkingDirectory}/mesh-artifact/${meshId}`;
+
+		const meshArtifacts = require(meshArtifactsPath);
+		const { getBuiltMesh } = meshArtifacts;
+
+		const tenantMesh = await getBuiltMesh();
+		const corsOptions = getCORSOptions();
+
+		logger.info('Creating graphQL server');
+
+		meshConfig = readMeshConfig(meshId);
+
+		yogaServer = createYoga({
+			plugins: tenantMesh.plugins,
+			graphqlEndpoint: `/graphql`,
+			graphiql: true,
+			cors: corsOptions,
+		});
+
+		return yogaServer;
+	}
+};
+
+const app = fastify();
+
+app.route({
+	method: ['GET', 'POST'],
+	url: '/graphql',
+	handler: async (req, res) => {
+		logger.info('Request received: ', req.body);
+
+		let body = null;
+		let responseBody = null;
+		let includeMetaData = false;
+
+		if (req.headers['x-include-metadata'] && req.headers['x-include-metadata'].length > 0) {
+			if (req.headers['x-include-metadata'].toLowerCase() === 'true') {
+				includeMetaData = true;
+			}
+		}
+
+		const response = await yogaServer.handleNodeRequest(req, {
+			req,
+			reply: res,
+		});
+
+		try {
+			try {
+				body = await response.text();
+				if (body) {
+					responseBody = JSON.parse(body);
+				}
+			} catch (err) {
+				logger.error(`Error parsing response body: ${err}`);
+				logger.error(response);
+				throw new Error(`Error parsing response body: ${err}`);
+			}
+			//Set the value of includeHTTPDetails flag
+
+			const includeHTTPDetails = !!meshConfig?.responseConfig?.includeHTTPDetails;
+			const meshHTTPDetails = responseBody?.extensions?.httpDetails;
+			logger.info('Mesh HTTP Details: ', meshHTTPDetails);
+
+			/* the logic for handling mesh response headers using includeMetaData */
+			prepSourceResponseHeaders(meshHTTPDetails, req.id);
+			const responseHeaders = processResponseHeaders(meshId, req.id, includeMetaData, req.method);
+
+			/** Adding the yoga response headers to the response */
+			response.headers?.forEach((value, key) => {
+				res.header(key, value);
+			});
+
+			// Delete the httpDetails extensions details if mesh owner has disabled those details in the config
+			if (includeHTTPDetails !== true) {
+				delete responseBody?.extensions?.httpDetails;
+			}
+
+			//make sure to remove the request headers from cache after the request is complete
+			removeRequestHeaders(req.id);
+			const fastifyResponseBody = JSON.stringify(responseBody);
+			res.status(response.status).headers(responseHeaders).send(fastifyResponseBody);
+		} catch (err) {
+			logger.error(`Error parsing response body: ${err}`);
+			//we have this fallback catch clause if someone wants to load the graphiql engine. This returns the default headers back
+			response.headers?.forEach((value, key) => {
+				res.header(key, value);
+			});
+			res.status(response.status);
+			res.send(response.body);
+		}
+
+		return res;
+	},
+});
+
+app.listen(
+	{
+		//set the port no of the server based on the input value
+		port: portNo,
+	},
+	async err => {
+		if (err) {
+			console.error(err);
+			process.exit(1);
+		}
+		yogaServer = await getYogaServer();
+
+		console.log(`Server is running on http://localhost:${portNo}/graphql`);
+	},
+);