@adobe/aio-cli-plugin-api-mesh 3.0.0 → 3.1.0-beta.1

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`);
+	},
+);

package/src/serverUtils.js

@@ -0,0 +1,323 @@
+const fs = require('fs');
+const path = require('path');
+const LRUCache = require('lru-cache');
+const logger = require('./classes/logger');
+
+const headersCache = new LRUCache({
+	max: parseInt(process.env.CACHE_OPT_MAX || '500', 10),
+	ttl: parseInt(process.env.CACHE_HEADERS_TTL || '300000', 10), // 5 mins
+	dispose: (value, key, reason) => {
+		logger.info(`Removing headers for ${key} from headers cache because ${reason}`);
+	},
+});
+
+/**
+ * Read .meshrc.json file stored in the mesh-artifact for a particular mesh
+ * Parse the file and store into meshConfig object
+ * @param appRootDir
+ * @param meshId
+ */
+function readMeshConfig(meshId) {
+	const configPath = path.resolve(process.cwd(), 'mesh-artifact', `${meshId}`, '.meshrc.json');
+	if (fs.existsSync(configPath)) {
+		const meshrcFile = fs.readFileSync(configPath).toString();
+
+		return JSON.parse(meshrcFile);
+	}
+}
+
+function removeRequestHeaders(requesId) {
+	headersCache.delete(requesId);
+}
+
+/**
+ * This function loops through the mesh http details plugin and saves the response headers into an LRU cache
+ * @param meshHTTPDetails this is the object coming from the graphql-mesh plugin that contains information about the different sources
+ * @param requestId
+ */
+function prepSourceResponseHeaders(meshHTTPDetails, requestId) {
+	const mappedResponseHeaders = [];
+	//const requestId = request_context_1.requestContext.get('requestId');
+	meshHTTPDetails?.forEach(element => {
+		const headers = Object.entries(element.response.headers);
+		headers?.forEach(value => {
+			const header = value[0];
+			const headerValue = value[1];
+			const sourceName = element.sourceName;
+			const url = element.request.url;
+			const mappedResponseHeader = {
+				name: header.toLowerCase(),
+				source: sourceName,
+				values: [headerValue],
+			};
+			const sourceMarkedHeader = {
+				name:
+					//we want to return all the original headers from magento and source prefixed for everyone else
+					header.toLowerCase() !== 'cache-control' && !url.toLowerCase().includes('magento')
+						? `x-${element.sourceName}-${header.toLowerCase()}`
+						: header.toLowerCase(),
+				source: sourceName,
+				values: [headerValue],
+			};
+			mappedResponseHeaders.push(sourceMarkedHeader);
+			mappedResponseHeaders.push(mappedResponseHeader);
+		});
+		//Update the headers LRU cache
+		setSourceResponseHeaders(requestId, mappedResponseHeaders);
+	});
+}
+
+function setSourceResponseHeaders(requestId, responseHeaders) {
+	if (headersCache.has(requestId)) {
+		const currentResponseHeaders = headersCache.get(requestId);
+		const concatResponseHeaders = currentResponseHeaders.concat(responseHeaders);
+		headersCache.set(requestId, concatResponseHeaders);
+	} else {
+		headersCache.set(requestId, responseHeaders);
+	}
+}
+
+/**
+ *
+ * @param meshId
+ * @param requestId
+ * @param includeMetadata
+ * @param method
+ * @returns {Object.<string, string|string[]>}
+ */
+function processResponseHeaders(meshId, requestId, includeMetadata, method) {
+	const meshResponseConfig = getMeshResponseConfig(meshId);
+	const responseHeaders = headersCache.get(requestId);
+	const sourceResponseConfig = getSourceResponseHeaders(
+		responseHeaders,
+		meshId,
+		requestId,
+		includeMetadata,
+	);
+	return processMeshResponseHeaders(
+		meshResponseConfig,
+		sourceResponseConfig,
+		method,
+		responseHeaders,
+	);
+}
+
+function getMeshResponseConfig(meshId) {
+	const meshConfig = readMeshConfig(meshId);
+	return meshConfig?.responseConfig;
+}
+
+function getSourceResponseHeaders(responseHeaders, meshId, requestId, includeMetadata) {
+	const sourceResponseHeaders = {};
+	const sourceResponseHeadersMap = new Map();
+
+	const currentWorkingDirectory = process.cwd();
+	const meshConfigPath = `${currentWorkingDirectory}/mesh-artifact/${meshId}/.meshrc.json`;
+
+	const meshConfig = require(meshConfigPath);
+	if (meshConfig) {
+		meshConfig.sources.forEach(source => {
+			if (source.responseConfig && source.responseConfig.headers) {
+				sourceResponseHeadersMap.set(source.name, source.responseConfig.headers);
+			}
+		});
+		responseHeaders?.forEach(element => {
+			const respArray = sourceResponseHeadersMap.get(element.source);
+			const lower = respArray?.map(element => {
+				return element.toLowerCase();
+			});
+			if (lower && lower.includes(element.name)) {
+				sourceResponseHeaders[element.name] = element.values;
+			}
+			if (includeMetadata) {
+				sourceResponseHeaders[element.name] = element.values;
+			}
+		});
+	} else {
+		logger.error(`No meshid ${meshId} found for requestId: ${requestId}`);
+		throw new Error(`No meshid ${meshId} found`, 'getSourceResponseHeaders', requestId);
+	}
+	//  }
+	return sourceResponseHeaders || {};
+}
+
+function processMeshResponseHeaders(
+	meshResponseConfig,
+	sourceResponseConfig,
+	method,
+	responseHeaders,
+) {
+	//Since we do not want any caching to happen on posts we need to make sure any cache-control headers
+	//are removed on posts. This includes at the mesh and source level
+	if (method.toLowerCase() === 'post') {
+		const removedCacheHeadersConfig = Object.fromEntries(
+			Object.entries(sourceResponseConfig).map(([k, v]) => [k.toLowerCase(), v]),
+		);
+		delete removedCacheHeadersConfig['cache-control'];
+		//if there are mesh headers we want to remove them as well
+		if (meshResponseConfig && meshResponseConfig.headers) {
+			const meshHeaders = Object.fromEntries(
+				Object.entries(meshResponseConfig.headers).map(([k, v]) => [
+					k.toLowerCase(),
+					v.toLowerCase(),
+				]),
+			);
+			delete meshHeaders['cache-control'];
+			return { ...meshHeaders } || {};
+		}
+		return { ...removedCacheHeadersConfig } || {};
+	}
+	//All other requests go through the usual path
+	if (meshResponseConfig && meshResponseConfig.headers) {
+		//make sure we are standardizing all the headers
+		const meshHeaders = Object.fromEntries(
+			Object.entries(meshResponseConfig.headers).map(([k, v]) => [
+				k.toLowerCase(),
+				v.toLowerCase(),
+			]),
+		);
+		return { ...meshHeaders, ...sourceResponseConfig } || {};
+	} else {
+		if (responseHeaders) {
+			const ccDirectives = getCacheControlDirectives(responseHeaders);
+			return { ...sourceResponseConfig, ...ccDirectives } || {};
+		}
+	}
+	return { ...sourceResponseConfig } || {};
+}
+
+/**
+ * Returns the lowest common denominator on all the sources cache-control headers
+ * @param responseHeaders
+ * @returns
+ */
+function getCacheControlDirectives(responseHeaders) {
+	let ccDirectives = {};
+	responseHeaders?.forEach(element => {
+		if (element.name.toLowerCase() === 'cache-control') {
+			const currentCacheMap = parseCacheControl(element.values.toString());
+			const standardDizedCacheMap = Object.fromEntries(
+				Object.entries(currentCacheMap).map(([k, v]) => [k.toLowerCase(), v.toLowerCase()]),
+			);
+			ccDirectives = resolveCacheDirectives(ccDirectives, standardDizedCacheMap);
+		}
+	});
+	return { 'cache-control': ccDirectivesToString(ccDirectives) };
+}
+
+/**
+ * Parses out the cache-control headers into a map
+ * @param directives
+ * @returns
+ */
+function parseCacheControl(directives) {
+	//                     1: directive                                                  =   2: token                                              3: quoted-string
+	// eslint-disable-next-line
+	const regex = /(?:^|(?:\s*\,\s*))([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)(?:\=(?:([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)|(?:\"((?:[^"\\]|\\.)*)\")))?/g;
+	const header = {};
+	const err = directives.replace(regex, function ($0, $1, $2, $3) {
+		const value = $2 || $3;
+		header[$1] = value ? value.toLowerCase() : $1;
+		return '';
+	});
+	return err ? {} : header;
+}
+
+/**
+ * Runs a lowest common denominator algorithm on the current source cache-control header
+ * @param lowestValuesCacheDirectives - object containing the lowest values of the cache-control headers
+ * @param currentDirectives - current source cache-control headers
+ * @returns lowestValuesCacheDirectives
+ */
+function resolveCacheDirectives(lowestValuesCacheDirectives, currentDirectives) {
+	//if any header contains no-store, we are done
+	if (lowestValuesCacheDirectives['no-store']) {
+		return lowestValuesCacheDirectives;
+	}
+	if (currentDirectives['no-store']) {
+		lowestValuesCacheDirectives = {};
+		lowestValuesCacheDirectives['no-store'] = 'no-store';
+		return lowestValuesCacheDirectives;
+	}
+	//id min values for each of these directives
+	const minDirectives = [
+		'min-fresh',
+		'max-age',
+		'max-stale',
+		's-maxage',
+		'stale-if-error',
+		'stale-while-revalidate',
+	];
+	minDirectives.forEach(element => {
+		updateToMin(element, currentDirectives[element], lowestValuesCacheDirectives);
+	});
+	//add these directives, if they are not already present
+	const otherDirectives = [
+		'public',
+		'private',
+		'immutable',
+		'no-cache',
+		'no-transform',
+		'must-revalidate',
+		'proxy-revalidate',
+		'must-understand',
+	];
+	Object.keys(currentDirectives).forEach(key => {
+		if (otherDirectives.includes(key) && !lowestValuesCacheDirectives[key]) {
+			lowestValuesCacheDirectives[key] = currentDirectives[key];
+		}
+	});
+	return lowestValuesCacheDirectives;
+}
+
+/**
+ * Updates a cache-control header value to the lowest value if required
+ * @param key
+ * @param candidateMin
+ * @param cachedHeaders
+ * @returns
+ */
+function updateToMin(key, candidateMin, cachedHeaders) {
+	//first check if both values exist and are not undefined
+	if (cachedHeaders[key] && candidateMin) {
+		//if the value to be replaced is not a number and the candidate is a number we do a direct replacement
+		if (isNaN(Number(cachedHeaders[key])) && !isNaN(Number(candidateMin))) {
+			cachedHeaders[key] = candidateMin;
+		}
+		//if both values are integers and the candidate is lower than the existing lowest value, replace the current value with the candidate
+		else if (!isNaN(Number(cachedHeaders[key])) && !isNaN(Number(candidateMin))) {
+			if (Number(cachedHeaders[key]) > Number(candidateMin)) {
+				cachedHeaders[key] = candidateMin;
+			}
+		}
+	}
+	//do a direct in-place update of the existing array
+	else if (candidateMin) {
+		cachedHeaders[key] = candidateMin;
+	}
+	return cachedHeaders;
+}
+
+/**
+ * Returns the cache-control headers as a string
+ * @param directives
+ * @returns
+ */
+function ccDirectivesToString(directives) {
+	const chStr = [];
+	Object.keys(directives).forEach(key => {
+		if (directives[key] === key) {
+			chStr.push(key);
+		} else {
+			chStr.push(key + '=' + directives[key]);
+		}
+	});
+	return chStr.toString();
+}
+
+module.exports = {
+	readMeshConfig,
+	removeRequestHeaders,
+	prepSourceResponseHeaders,
+	processResponseHeaders,
+};

package/src/templates/package.json

@@ -5,25 +5,35 @@
 		"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"
+		"@graphql-mesh/cli": "0.82.30",
+		"@graphql-mesh/graphql": "0.34.13",
+		"@graphql-mesh/json-schema": "0.35.38",
+		"@graphql-mesh/openapi": "0.33.39",
+		"@graphql-mesh/plugin-http-details-extensions": "0.1.21",
+		"@graphql-mesh/runtime": "0.46.21",
+		"@graphql-mesh/transform-encapsulate": "0.4.21",
+		"@graphql-mesh/transform-federation": "0.11.14",
+		"@graphql-mesh/transform-filter-schema": "0.15.23",
+		"@graphql-mesh/transform-hoist-field": "0.2.21",
+		"@graphql-mesh/transform-naming-convention": "0.13.22",
+		"@graphql-mesh/transform-prefix": "0.12.22",
+		"@graphql-mesh/transform-prune": "0.1.20",
+		"@graphql-mesh/transform-rename": "0.14.22",
+		"@graphql-mesh/transform-replace-field": "0.4.20",
+		"@graphql-mesh/transform-resolvers-composition": "0.13.20",
+		"@graphql-mesh/transform-type-merging": "0.5.20",
+		"@graphql-mesh/types": "0.91.12",
+		"@graphql-mesh/soap": "0.14.25",
+		"@graphql-mesh/http": "^0.96.9",
+		"graphql": "^16.6.0",
+		"@adobe/plugin-hooks": "^0.1.0",
+		"@adobe/plugin-on-fetch": "^0.1.0",
+		"eslint-plugin-no-loops": "^0.3.0",
+		"eslint-plugin-node": "^11.1.0",
+		"eslint-plugin-security": "^1.5.0",
+		"eslint-plugin-sonarjs": "^0.16.0",
+		"fastify": "^4.10.2",
+		"graphql-yoga": "3.1.1"
 	},
 	"engines": {
 		"node": ">=18.0.0"

package/src/utils.js

@@ -41,6 +41,16 @@ const envFileFlag = Flags.string({
 	default: '.env',
 });
 
+const portNoFlag = Flags.integer({
+	char: 'p',
+	description: 'Port number for the local dev server',
+});
+
+const debugFlag = Flags.boolean({
+	description: 'Enable debugging mode',
+	default: false,
+});
+
 /**
  * Parse the meshConfig and get the list of (local) files to be imported
  *
@@ -387,4 +397,6 @@ module.exports = {
 	validateEnvFileFormat,
 	validateAndInterpolateMesh,
 	getAppRootDir,
+	portNoFlag,
+	debugFlag,
 };

package/src/uuid.js

@@ -0,0 +1,21 @@
+const { v4: uuidv4 } = require('uuid');
+
+/**
+ * Class representing a UUID object which is used as a param across the application
+ */
+class UUID {
+	constructor(str) {
+		this.m_str = str || UUID.newUuid().toString();
+	}
+
+	toString() {
+		return this.m_str;
+	}
+
+	static newUuid() {
+		const uuid = uuidv4();
+		return new UUID(uuid);
+	}
+}
+
+module.exports = UUID;