@steedos/moleculer-apollo-server 3.0.0-beta.7

package/index.js

@@ -0,0 +1,50 @@
+/*
+ * moleculer-apollo-server
+ *
+ * Apollo Server for Moleculer API Gateway.
+ *
+ * Based on "apollo-server-micro"
+ *
+ * 		https://github.com/apollographql/apollo-server/blob/master/packages/apollo-server-micro/
+ *
+ *
+ * Copyright (c) 2020 MoleculerJS (https://github.com/moleculerjs/moleculer-apollo-server)
+ * MIT Licensed
+ */
+
+"use strict";
+
+const core = require("apollo-server-core");
+const { GraphQLUpload } = require("graphql-upload");
+const { ApolloServer } = require("./src/ApolloServer");
+const ApolloService = require("./src/service");
+const gql = require("./src/gql");
+
+module.exports = {
+	// Core
+	GraphQLExtension: core.GraphQLExtension,
+	gql: core.gql,
+	ApolloError: core.ApolloError,
+	toApolloError: core.toApolloError,
+	SyntaxError: core.SyntaxError,
+	ValidationError: core.ValidationError,
+	AuthenticationError: core.AuthenticationError,
+	ForbiddenError: core.ForbiddenError,
+	UserInputError: core.UserInputError,
+	defaultPlaygroundOptions: core.defaultPlaygroundOptions,
+
+	// GraphQL tools
+	...require("graphql-tools"),
+
+	// GraphQL Upload
+	GraphQLUpload,
+
+	// Apollo Server
+	ApolloServer,
+
+	// Apollo Moleculer Service
+	ApolloService,
+
+	// Moleculer gql formatter
+	moleculerGql: gql,
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+	"name": "@steedos/moleculer-apollo-server",
+	"private": false,
+	"version": "3.0.0-beta.7",
+	"description": "Apollo GraphQL server for Moleculer API Gateway",
+	"main": "index.js",
+	"scripts": {
+		"dev": "nodemon examples/index.js",
+		"ci": "jest --watch",
+		"test": "jest --coverage",
+		"ci:integration": "jest \"**/integration/**spec.js\" --watch",
+		"lint": "eslint --ext=.js src test",
+		"lint:fix": "eslint --fix --ext=.js src test",
+		"deps": "npm-check -u",
+		"postdeps": "npm test",
+		"coverall": "cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js"
+	},
+	"keywords": [
+		"graphql",
+		"apollo-server",
+		"apollo",
+		"moleculer",
+		"microservice",
+		"gateway"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/moleculerjs/moleculer-apollo-server.git"
+	},
+	"author": "MoleculerJS",
+	"license": "MIT",
+	"jest": {
+		"coverageDirectory": "../coverage",
+		"testEnvironment": "node",
+		"rootDir": "./src",
+		"roots": [
+			"../test"
+		],
+		"coveragePathIgnorePatterns": [
+			"/node_modules/",
+			"/test/services/"
+		]
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"engines": {
+		"node": ">= 10.x.x"
+	},
+	"dependencies": {
+		"@apollographql/graphql-playground-html": "^1.6.29",
+		"@hapi/accept": "^3.2.4",
+		"@types/graphql-upload": "^8.0.11",
+		"apollo-server-core": "^2.22.2",
+		"dataloader": "^2.1.0",
+		"graphql-subscriptions": "^1.2.1",
+		"graphql-tools": "^9.0.11",
+		"graphql-upload": "^11.0.0",
+		"lodash": "^4.17.21",
+		"object-hash": "^2.2.0"
+	},
+	"gitHead": "b68a33d2fa33b380aa7ec401b63315886f7de861"
+}

package/src/ApolloServer.js

@@ -0,0 +1,113 @@
+"use strict";
+
+const { ApolloServerBase } = require("apollo-server-core");
+const { processRequest } = require("graphql-upload");
+const { renderPlaygroundPage } = require("@apollographql/graphql-playground-html");
+const accept = require("@hapi/accept");
+const moleculerApollo = require("./moleculerApollo");
+
+async function send(req, res, statusCode, data, responseType = "application/json") {
+	res.statusCode = statusCode;
+
+	const ctx = res.$ctx;
+	if (!ctx.meta.$responseType) {
+		ctx.meta.$responseType = responseType;
+	}
+
+	const route = res.$route;
+	if (route.onAfterCall) {
+		data = await route.onAfterCall.call(this, ctx, route, req, res, data);
+	}
+
+	const service = res.$service;
+	service.sendResponse(req, res, data);
+}
+
+class ApolloServer extends ApolloServerBase {
+	// Extract Apollo Server options from the request.
+	createGraphQLServerOptions(req, res) {
+		return super.graphQLServerOptions({ req, res });
+	}
+
+	// Prepares and returns an async function that can be used to handle
+	// GraphQL requests.
+	createHandler({ path, disableHealthCheck, onHealthCheck } = {}) {
+		const promiseWillStart = this.willStart();
+
+		return async (req, res) => {
+			this.graphqlPath = path || "/graphql";
+
+			await promiseWillStart;
+
+			// If file uploads are detected, prepare them for easier handling with
+			// the help of `graphql-upload`.
+			if (this.uploadsConfig) {
+				const contentType = req.headers["content-type"];
+				if (contentType && contentType.startsWith("multipart/form-data")) {
+					req.filePayload = await processRequest(req, res, this.uploadsConfig);
+				}
+			}
+
+			// If health checking is enabled, trigger the `onHealthCheck`
+			// function when the health check URL is requested.
+			if (!disableHealthCheck && req.url === "/.well-known/apollo/server-health")
+				return await this.handleHealthCheck({ req, res, onHealthCheck });
+
+			// If the `playgroundOptions` are set, register a `graphql-playground` instance
+			// (not available in production) that is then used to handle all
+			// incoming GraphQL requests.
+			if (this.playgroundOptions && req.method === "GET") {
+				const { mediaTypes } = accept.parseAll(req.headers);
+				const prefersHTML =
+					mediaTypes.find(x => x === "text/html" || x === "application/json") ===
+					"text/html";
+
+				if (prefersHTML) {
+					const middlewareOptions = Object.assign(
+						{
+							endpoint: this.graphqlPath,
+							subscriptionEndpoint: this.subscriptionsPath,
+						},
+						this.playgroundOptions
+					);
+					return send(
+						req,
+						res,
+						200,
+						renderPlaygroundPage(middlewareOptions),
+						"text/html"
+					);
+				}
+			}
+
+			// Handle incoming GraphQL requests using Apollo Server.
+			const graphqlHandler = moleculerApollo(() => this.createGraphQLServerOptions(req, res));
+			const responseData = await graphqlHandler(req, res);
+			return send(req, res, 200, responseData);
+		};
+	}
+
+	// This integration supports file uploads.
+	supportsUploads() {
+		return true;
+	}
+
+	// This integration supports subscriptions.
+	supportsSubscriptions() {
+		return true;
+	}
+
+	async handleHealthCheck({ req, res, onHealthCheck }) {
+		onHealthCheck = onHealthCheck || (() => undefined);
+		try {
+			const result = await onHealthCheck(req);
+			return send(req, res, 200, { status: "pass", result }, "application/health+json");
+		} catch (error) {
+			const result = error instanceof Error ? error.toString() : error;
+			return send(req, res, 503, { status: "fail", result }, "application/health+json");
+		}
+	}
+}
+module.exports = {
+	ApolloServer,
+};

package/src/gql.js

@@ -0,0 +1,22 @@
+const { zip } = require("lodash");
+
+/**
+ * @function gql Format graphql strings for usage in moleculer-apollo-server
+ * @param {TemplateStringsArray} typeString - Template string array for formatting
+ * @param  {...string} placeholders - Placeholder expressions
+ */
+const gql = (typeString, ...placeholders) => {
+	// combine template string array and placeholders into a single string
+	const zipped = zip(typeString, placeholders);
+	const combinedString = zipped.reduce(
+		(prev, [next, placeholder]) => `${prev}${next}${placeholder || ""}`,
+		"",
+	);
+	const re = /type\s+(Query|Mutation|Subscription)\s+{(.*?)}/s;
+
+	const result = re.exec(combinedString);
+	// eliminate Query/Mutation/Subscription wrapper if present as moleculer-apollo-server will stitch them together
+	return Array.isArray(result) ? result[2] : combinedString;
+};
+
+module.exports = gql;

package/src/moleculerApollo.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const { runHttpQuery, convertNodeHttpToRequest } = require("apollo-server-core");
+const url = require("url");
+
+// Utility function used to set multiple headers on a response object.
+function setHeaders(res, headers) {
+	Object.keys(headers).forEach(header => res.setHeader(header, headers[header]));
+}
+
+module.exports = function graphqlMoleculer(options) {
+	if (!options) {
+		throw new Error("Apollo Server requires options.");
+	}
+
+	if (arguments.length > 1) {
+		throw new Error(`Apollo Server expects exactly one argument, got ${arguments.length}`);
+	}
+
+	return async function graphqlHandler(req, res) {
+		let query;
+		try {
+			if (req.method === "POST") {
+				query = req.filePayload || req.body;
+			} else {
+				query = url.parse(req.url, true).query;
+			}
+		} catch (error) {
+			// Do nothing; `query` stays `undefined`
+		}
+
+		try {
+			const { graphqlResponse, responseInit } = await runHttpQuery([req, res], {
+				method: req.method,
+				options,
+				query,
+				request: convertNodeHttpToRequest(req),
+			});
+
+			setHeaders(res, responseInit.headers);
+
+			return graphqlResponse;
+		} catch (error) {
+			if ("HttpQueryError" === error.name && error.headers) {
+				setHeaders(res, error.headers);
+			}
+
+			if (!error.statusCode) {
+				error.statusCode = 500;
+			}
+
+			res.statusCode = error.statusCode || error.code || 500;
+			res.end(error.message);
+
+			return undefined;
+		}
+	};
+};