@adobe/aio-cli-plugin-api-mesh 4.1.0 → 5.0.0-alpha

package/src/server.js

@@ -1,38 +1,200 @@
-const { spawn } = require('child_process');
-const { readSecretsFile } = require('./serverUtils');
-const packageData = require('../package.json');
-
-const runServer = portNo => {
-	const wranglerPackageNumber = packageData.dependencies.wrangler;
-	const wranglerVersion = `wrangler@${wranglerPackageNumber.replace(/^[\^~]/, '')}`;
-	const indexFilePath = `${__dirname}/index.js`;
-	const filePath = '.mesh';
-	const secrets = readSecretsFile(filePath);
-	const commandArgs = [
-		wranglerVersion,
-		'dev',
-		indexFilePath,
-		'--show-interactive-dev-session',
-		'false',
-		'--var',
-		`Secret:${JSON.stringify(secrets)}`,
-		'--port',
-		portNo,
-		'--inspector-port',
-		'9229',
-	];
-
-	const wrangler = spawn('npx', commandArgs, {
-		stdio: 'inherit',
-	});
-
-	wrangler.on('close', code => {
-		console.log(`wrangler dev process exited with code ${code}`);
-	});
-
-	wrangler.on('error', error => {
-		console.error(`Failed to start wrangler dev: ${error.message}`);
-	});
+// 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,
+	readSecretsFile,
+} = 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 {};
+	}
+};
+
+// Custom get secrets handler
+const getSecretsHandler = {
+	get: function (target, prop, receiver) {
+		if (prop === 'toJSON') {
+			// Handle the toJSON case
+			return () => target;
+		}
+		if (prop in target) {
+			return Reflect.get(target, prop, receiver);
+		} else {
+			throw new Error(`The secret ${String(prop)} is not available.`);
+		}
+	},
+	set: function () {
+		throw new Error('Setting secrets is not allowed');
+	},
 };
 
-module.exports = { runServer };
+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();
+
+		const secrets = readSecretsFile(meshId);
+
+		const secretsProxy = new Proxy(secrets, getSecretsHandler);
+
+		logger.info('Creating graphQL server');
+
+		meshConfig = readMeshConfig(meshId);
+
+		yogaServer = createYoga({
+			plugins: tenantMesh.plugins,
+			graphqlEndpoint: `/graphql`,
+			graphiql: true,
+			maskedErrors: false,
+			cors: corsOptions,
+			context: initialContext => ({
+				...initialContext,
+				secrets: secretsProxy,
+			}),
+		});
+
+		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 => {
+		try {
+			if (err) {
+				throw new Error(`Server setup error: ${err.message}`);
+			}
+			yogaServer = await getYogaServer();
+		} catch (error) {
+			console.error(error);
+			process.exit(1);
+		}
+
+		console.log(`Server is running on http://localhost:${portNo}/graphql`);
+	},
+);

package/src/serverUtils.js

@@ -318,13 +318,13 @@ function ccDirectivesToString(directives) {
 
 /**
  * Returns secrets content from artifacts
- * @param meshPath
+ * @param meshId
  * @returns
  */
-function readSecretsFile(meshPath) {
+function readSecretsFile(meshId) {
 	let secrets = {};
 	try {
-		const filePath = path.resolve(process.cwd(), `${meshPath}`, 'secrets.yaml');
+		const filePath = path.resolve(process.cwd(), 'mesh-artifact', `${meshId}`, 'secrets.yaml');
 		if (fs.existsSync(filePath)) {
 			secrets = YAML.parse(fs.readFileSync(filePath, 'utf8'));
 		}

package/src/cors.js

@@ -1,28 +0,0 @@
-/**
- * Get default CORS options.
- * @param env Environment.
- */
-const getDefaultCorsOptions = env => {
-	return env.CORS_DEFAULT_URL
-		? {
-				origin: env.CORS_DEFAULT_URL,
-		  }
-		: {};
-};
-
-/**
- * Get CORS options. Merges default CORS options with custom specific options if present in the mesh configuration.
- * Custom CORS options overwrite the default options to ensure that specific requirements can be met without altering
- * the default configuration.
- * @param env Environment.
- * @param meshConfig Mesh configuration.
- */
-const getCorsOptions = (env, meshConfig) => {
-	const defaultCorsOptions = getDefaultCorsOptions(env);
-	return {
-		...defaultCorsOptions,
-		...meshConfig.responseConfig?.CORS,
-	};
-};
-
-module.exports = { getCorsOptions };

package/src/fixPlugins.js

@@ -1,28 +0,0 @@
-/* eslint-disable no-console */
-const fs = require('fs');
-/**
- * Modifies `index.js` of a mesh artifact to mutate plugin references for edge compatibility. Current forces
- * `@graphql-mesh/plugin-http-details-extensions` to resolve to local fork instead.
- */
-async function fixPlugins(meshArtifactPath) {
-	try {
-		console.log('Modifying mesh artifact to fix plugins for edge compatibility.');
-		const data = fs.readFileSync(meshArtifactPath, 'utf8');
-		const updatedData = data.replace(
-			/@graphql-mesh\/plugin-http-details-extensions/g,
-			'../src/plugins/httpDetailsExtensions',
-		);
-		fs.writeFileSync(meshArtifactPath, updatedData, 'utf8');
-	} catch (err) {
-		console.error(err);
-	}
-}
-
-// Execute fixPlugins if run directly from CLI
-if (require.main === module) {
-	fixPlugins();
-}
-
-module.exports = {
-	fixPlugins,
-};

package/src/index.js

@@ -1,44 +0,0 @@
-import { ServedTier, addServedHeader } from './served';
-import { bindedlogger as logger } from './utils/logger';
-import { getRequestId } from './utils/requestId';
-import { buildServer } from './wranglerServer';
-
-let server;
-
-export default {
-	setServer(newServer) {
-		server = newServer;
-	},
-	/**
-	 * Fetch.
-	 * @param request Request.
-	 * @param env Environment.
-	 * @param ctx Event context.
-	 */
-	async fetch(request, env, ctx) {
-		const requestId = getRequestId(request);
-		// Retrieve environment variables
-		const { MESH_ID: meshId, LOG_LEVEL: logLevel } = env;
-		const loggerInstance = logger({ logLevel, meshId, requestId });
-		const meshArtifacts = await import('../.mesh');
-		const rawMesh = await import('../.mesh/.meshrc.json');
-
-		if (!server) {
-			server = await this.buildAndCacheServer(env, loggerInstance, meshArtifacts, rawMesh);
-		}
-
-		loggerInstance.debug('WORKER HOT: Fetching via worker');
-		const response = await server.fetch(request, ctx);
-		addServedHeader(response, ServedTier.WORKER_HOT);
-		return response;
-	},
-	/**
-	 * Build and cache mesh instance/server in global variable.
-	 * @param env
-	 * @param loggerInstance
-	 */
-	async buildAndCacheServer(env, loggerInstance, meshArtifacts, meshConfig) {
-		server = await buildServer(loggerInstance, env, meshArtifacts, meshConfig);
-		return server;
-	},
-};

package/src/plugins/complianceHeaders/complianceHeaders.js

@@ -1,55 +0,0 @@
-/**
- * CF-Connecting-IP provides the client IP address connecting to Cloudflare to the origin web server. This header will only be sent on the
- * traffic from Cloudflare’s edge to your origin web server. Upstream requests will the Cloudflare Worker client IP address of
- * `2a06:98c0:3600::103`.
- * @see https://developers.cloudflare.com/fundamentals/reference/http-request-headers/#cf-connecting-ip
- */
-const CF_CONNECTING_IP_HEADER = 'cf-connecting-ip';
-
-/**
- * The X-Forwarded-For (XFF) request header is a de-facto standard header for identifying the originating IP address of a client connecting
- * to a web server through a proxy server.
- * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For
- */
-const X_FORWARDED_FOR_HEADER = 'x-forwarded-for';
-
-/**
- * Add `x-forwarded-for` header from request context to each fetch.
- * @param context Request context.
- * @param headers Fetch headers.
- */
-const addXForwardedForHeader = (context, headers) => {
-	// `cf-connecting-ip` header contains the original visitor's IP address
-	const connectingIp = context?.request.headers.get(CF_CONNECTING_IP_HEADER);
-	const xForwardedFor = context?.request.headers.get(X_FORWARDED_FOR_HEADER);
-	if (connectingIp) {
-		if (!xForwardedFor) {
-			// Construct new `x-forwarded-for` header if not present in original request
-			headers.set(X_FORWARDED_FOR_HEADER, connectingIp);
-		} else {
-			// Construct `x-forwarded-for` header using original header
-			headers.set(X_FORWARDED_FOR_HEADER, `${xForwardedFor}, ${connectingIp}`);
-		}
-	}
-};
-
-/**
- * Adds compliance headers to source fetch requests.
- */
-function useComplianceHeaders() {
-	return {
-		onFetch({ context, options }) {
-			// Construct mutable headers from options passed to each fetch
-			const headers = new Headers(options.headers);
-			addXForwardedForHeader(context, headers);
-			options.headers = headers;
-		},
-	};
-}
-
-module.exports = {
-	useComplianceHeaders,
-	CF_CONNECTING_IP_HEADER,
-	X_FORWARDED_FOR_HEADER,
-	addXForwardedForHeader,
-};

package/src/plugins/complianceHeaders/index.js

@@ -1,2 +0,0 @@
-const { useComplianceHeaders } = require('./complianceHeaders');
-module.exports = useComplianceHeaders;

package/src/plugins/httpDetailsExtensions/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 Uri Goldshtein
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/src/plugins/httpDetailsExtensions/index.js

@@ -1,81 +0,0 @@
-/**
- * Fork of https://github.com/ardatan/graphql-mesh/blob/%40graphql-mesh/plugin-http-details-extensions%400.1.21/packages/plugins/http-details-extensions/src/index.ts
- * Version: 0.1.21
- * TODO: Extract to a separate repository/artifact after approach has been validated.
- */
-
-/* eslint-disable */
-
-const { isAsyncIterable } = require('@envelop/core');
-const { getHeadersObj } = require('@graphql-mesh/utils');
-
-function useIncludeHttpDetailsInExtensions(opts) {
-	if (!opts.if) {
-		return {};
-	}
-
-	const httpDetailsByContext = new WeakMap();
-
-	function getHttpDetailsByContext(context) {
-		let httpDetails = httpDetailsByContext.get(context);
-		if (!httpDetails) {
-			httpDetails = [];
-			httpDetailsByContext.set(context, httpDetails);
-		}
-		return httpDetails;
-	}
-
-	return {
-		onFetch({ url, context, info, options }) {
-			if (context != null) {
-				const requestTimestamp = Date.now();
-				return ({ response }) => {
-					const responseTimestamp = Date.now();
-					const responseTime = responseTimestamp - requestTimestamp;
-					const httpDetailsList = getHttpDetailsByContext(context);
-					const httpDetails = {
-						sourceName: (info)?.sourceName,
-						path: info?.path,
-						request: {
-							timestamp: requestTimestamp,
-							url,
-							method: options.method || 'GET',
-							headers: getHeadersObj(options.headers),
-						},
-						response: {
-							timestamp: responseTimestamp,
-							status: response.status,
-							statusText: response.statusText,
-							headers: getHeadersObj(response.headers),
-							// Added to interface to account for edge fetch implementation/behavior
-							cookies: response.headers.getSetCookie(),
-						},
-						responseTime,
-					};
-					httpDetailsList.push(httpDetails);
-				};
-			}
-			return undefined;
-		},
-		onExecute({ args: { contextValue } }) {
-			return {
-				onExecuteDone({ result, setResult }) {
-					if (!isAsyncIterable(result)) {
-						const httpDetailsList = httpDetailsByContext.get(contextValue);
-						if (httpDetailsList != null) {
-							setResult({
-								...result,
-								extensions: {
-									...result.extensions,
-									httpDetails: httpDetailsList,
-								},
-							});
-						}
-					}
-				},
-			};
-		},
-	};
-}
-
-module.exports = useIncludeHttpDetailsInExtensions;

package/src/secrets.js

@@ -1,34 +0,0 @@
-// Parse the yaml secrets string from env to json object
-function loadMeshSecrets(logger, secret) {
-	let parsedSecrets = {};
-
-	try {
-		// Replace escaped backslashes with a single backslash
-		secret = secret.replace(/\\"/g, '"');
-		parsedSecrets = JSON.parse(secret);
-	} catch (err) {
-		logger.error('Error parsing secrets.');
-	}
-
-	return parsedSecrets;
-}
-
-// Custom get secrets handler
-const getSecretsHandler = {
-	get: function (target, prop, receiver) {
-		if (prop === 'toJSON') {
-			// Handle the toJSON case
-			return () => target;
-		}
-		if (prop in target) {
-			return Reflect.get(target, prop, receiver);
-		} else {
-			throw new Error(`The secret ${String(prop)} is not available.`);
-		}
-	},
-	set: function () {
-		throw new Error('Setting secrets is not allowed');
-	},
-};
-
-module.exports = { loadMeshSecrets, getSecretsHandler };

package/src/served.js

@@ -1,22 +0,0 @@
-/**
- * Header to indicate which tier served the request.
- */
-const SERVE_TIER_HEADER = 'x-api-mesh-served';
-
-/**
- * Tiers that served the request.
- */
-const ServedTier = {
-	WORKER_HOT: 0,
-};
-
-/**
- * Add the served header to the response. Requires mutable headers on the response object.
- * @param response Response.
- * @param servedTier Tier that served the request.
- */
-const addServedHeader = (response, servedTier) => {
-	response.headers.set(SERVE_TIER_HEADER, servedTier.toString());
-};
-
-module.exports = { ServedTier, addServedHeader };

package/src/templates/wrangler.toml

@@ -1,14 +0,0 @@
-# Tenant worker core definition. For platform workers metadata configs are used to set bindings.
-name = "tenant-worker-core"
-compatibility_date = "2024-06-03"
-node_compat = false
-
-find_additional_modules = true
-base_dir = ".mesh"
-rules = [
-  { type = "CommonJS", globs = ["tenantFiles/**/*.js"] }
-]
-
-
-[[migrations]]
-tag = "v1"

package/src/utils/logger.js

@@ -1,42 +0,0 @@
-const pino = require('pino');
-
-/**
- * Get a new instance of a Pino logger with default configuration.
- * @param level Log level.
- */
-const pinoLogger = level =>
-	pino({
-		level: level || 'info',
-		formatters: {
-			level(label) {
-				return {
-					level: label,
-				};
-			},
-		},
-	});
-
-/**
- * Get a new instance of a Pino logger with default configuration and child bindings.
- * @param bindings Logger bindings.
- */
-const logger = bindings => {
-	return pinoLogger(bindings?.logLevel).child({
-		meshId: bindings?.meshId,
-		requestId: bindings?.requestId,
-	});
-};
-
-/**
- * Create a logger from environment/request.
- * @param bindings Logger bindings.
- */
-const bindedlogger = bindings => {
-	return logger({
-		logLevel: bindings?.logLevel,
-		meshId: bindings?.meshId,
-		requestId: bindings?.requestId,
-	});
-};
-
-module.exports = { logger, pinoLogger, bindedlogger };

package/src/utils/requestId.js

@@ -1,26 +0,0 @@
-const UUID = require('../uuid');
-
-/**
- * Default request identifier header name.
- */
-const DEFAULT_REQUEST_ID_HEADER_NAME = 'x-request-id';
-
-/**
- * Get request identifier from headers. Will attempt to set request identifier if not present.
- * @param request Request.
- * @param headerName Request identifier header name.
- */
-function getRequestId(request, headerName = DEFAULT_REQUEST_ID_HEADER_NAME) {
-	let requestId = request.headers.get(headerName);
-	if (!requestId) {
-		requestId = UUID.newUuid().toString();
-		try {
-			request.headers.set(headerName, requestId);
-		} catch (err) {
-			// Unable to set request headers
-		}
-	}
-	return requestId;
-}
-
-module.exports = { DEFAULT_REQUEST_ID_HEADER_NAME, getRequestId };