Merge pull request #150 from graphql/export-get-params

Adds getGraphQLParams

Author: leebyron

README.md

@@ -141,6 +141,15 @@ new GraphQLObjectType({
 ```
 
 
+## Other Exports
+
+**`getGraphQLParams(request: Request): Promise<GraphQLParams>`**
+
+Given an HTTP Request, this returns a Promise for the parameters relevant to
+running a GraphQL request. This function is used internally to handle the
+incoming request, you may use it directly for building other similar services.
+
+
 ## Debugging Tips
 
 During development, it's useful to get more information from errors, such as

src/index.js

@@ -24,8 +24,15 @@ import url from 'url';
 import { parseBody } from './parseBody';
 import { renderGraphiQL } from './renderGraphiQL';
 
-import type { Request, Response } from 'express';
-
+import type { Response } from 'express';
+
+export type Request = {
+  method: string;
+  url: string;
+  body: mixed;
+  headers: {[header: string]: mixed};
+  pipe<T>(stream: T): T;
+};
 
 /**
  * Used to configure the graphqlHTTP middleware by providing a schema
@@ -147,17 +154,14 @@ export default function graphqlHTTP(options: Options): Middleware {
         throw httpError(405, 'GraphQL only supports GET and POST requests.');
       }
 
-      // Parse the Request body.
-      return parseBody(request);
-    }).then(bodyData => {
-      const urlData = request.url && url.parse(request.url, true).query || {};
-      showGraphiQL = graphiql && canDisplayGraphiQL(request, urlData, bodyData);
-
+      // Parse the Request to get GraphQL request parameters.
+      return getGraphQLParams(request);
+    }).then(params => {
       // Get GraphQL params from the request and POST body data.
-      const params = getGraphQLParams(urlData, bodyData);
       query = params.query;
       variables = params.variables;
       operationName = params.operationName;
+      showGraphiQL = graphiql && canDisplayGraphiQL(request, params);
 
       // If there is no query, but GraphiQL will be displayed, do not produce
       // a result, otherwise return a 400: Bad Request.
@@ -252,16 +256,28 @@ export default function graphqlHTTP(options: Options): Middleware {
   };
 }
 
-type GraphQLParams = {
+export type GraphQLParams = {
   query: ?string;
   variables: ?{[name: string]: mixed};
   operationName: ?string;
+  raw: ?boolean;
 };
 
+/**
+ * Provided a "Request" provided by express or connect (typically a node style
+ * HTTPClientRequest), Promise the GraphQL request parameters.
+ */
+export function getGraphQLParams(request: Request): Promise<GraphQLParams> {
+  return parseBody(request).then(bodyData => {
+    const urlData = request.url && url.parse(request.url, true).query || {};
+    return parseGraphQLParams(urlData, bodyData);
+  });
+}
+
 /**
  * Helper function to get the GraphQL params from the request.
  */
-function getGraphQLParams(
+function parseGraphQLParams(
   urlData: {[param: string]: mixed},
   bodyData: {[param: string]: mixed}
 ): GraphQLParams {
@@ -289,22 +305,22 @@ function getGraphQLParams(
     operationName = null;
   }
 
-  return { query, variables, operationName };
+  const raw = urlData.raw !== undefined || bodyData.raw !== undefined;
+
+  return { query, variables, operationName, raw };
 }
 
 /**
  * Helper function to determine if GraphiQL can be displayed.
  */
 function canDisplayGraphiQL(
   request: Request,
-  urlData: {[param: string]: mixed},
-  bodyData: {[param: string]: mixed}
+  params: GraphQLParams
 ): boolean {
   // If `raw` exists, GraphiQL mode is not enabled.
-  const raw = urlData.raw !== undefined || bodyData.raw !== undefined;
   // Allowed to show GraphiQL if not requested as raw and this request
   // prefers HTML over JSON.
-  return !raw && accepts(request).types([ 'json', 'html' ]) === 'html';
+  return !params.raw && accepts(request).types([ 'json', 'html' ]) === 'html';
 }
 
 /**

src/parseBody.js

@@ -14,13 +14,19 @@ import httpError from 'http-errors';
 import querystring from 'querystring';
 import zlib from 'zlib';
 
-import type { Request } from 'express';
+import type { Request } from './index';
 
+/**
+ * Provided a "Request" provided by express or connect (typically a node style
+ * HTTPClientRequest), Promise the body data contained.
+ */
 export function parseBody(req: Request): Promise<{[param: string]: mixed}> {
   return new Promise((resolve, reject) => {
+    const body = req.body;
+
     // If express has already parsed a body as a keyed object, use it.
-    if (typeof req.body === 'object' && !(req.body instanceof Buffer)) {
-      return resolve(req.body);
+    if (typeof body === 'object' && !(body instanceof Buffer)) {
+      return resolve((body: any));
     }
 
     // Skip requests without content types.
@@ -32,13 +38,12 @@ export function parseBody(req: Request): Promise<{[param: string]: mixed}> {
 
     // If express has already parsed a body as a string, and the content-type
     // was application/graphql, parse the string body.
-    if (typeof req.body === 'string' &&
-        typeInfo.type === 'application/graphql') {
-      return resolve(graphqlParser(req.body));
+    if (typeof body === 'string' && typeInfo.type === 'application/graphql') {
+      return resolve(graphqlParser(body));
     }
 
     // Already parsed body we didn't recognise? Parse nothing.
-    if (req.body) {
+    if (body) {
       return resolve({});
     }
 
@@ -99,14 +104,16 @@ function read(req, typeInfo, parseFn, resolve, reject) {
   }
 
   // Get content-encoding (e.g. gzip)
-  const encoding =
-    (req.headers['content-encoding'] || 'identity').toLowerCase();
+  const contentEncoding = req.headers['content-encoding'];
+  const encoding = typeof contentEncoding === 'string' ?
+    contentEncoding.toLowerCase() :
+    'identity';
   const length = encoding === 'identity' ? req.headers['content-length'] : null;
   const limit = 100 * 1024; // 100kb
   const stream = decompressed(req, encoding);
 
   // Read body from stream.
-  getBody(stream, { encoding: charset, length, limit }, function (err, body) {
+  getBody(stream, { encoding: charset, length, limit }, (err, body) => {
     if (err) {
       return reject(
         err.type === 'encoding.unsupported' ?