graphql / express-graphql / 197

pending completion

Build # 197

Build Type

Pull #82

travis-ci

Committed by

calebmer

Commit Message

<a href="https://github.com/graphql/express-graphql/commit/<a class=hub.com/graphql/express-graphql/commit/6757332e2606c4690e24b49c05c1485fa2dd656e">6757332e2<a href="https://github.com/graphql/express-graphql/commit/6757332e2606c4690e24b49c05c1485fa2dd656e">&quot;&gt;Revert &amp;quot;Move graphqlHTTP into own file&quot;

This reverts commit </a><a class="double-link" href="https://github.com/graphql/express-graphql/commit/<a class="double-link" href="https://github.com/graphql/express-graphql/commit/ea612c62513b138d1eaeaacb6abee5eaf3d84c85">ea612c625</a>">ea612c625</a><a href="https://github.com/graphql/express-graphql/commit/6757332e2606c4690e24b49c05c1485fa2dd656e">.

# Conflicts:
#	src/graphqlHTTP.js

Pull Request Pull Request #82: Connect support

Run Details

87 of 87 new or added lines in 2 files covered. (100.0%)

610 of 611 relevant lines covered (99.84%)

25.04 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.97

/src/index.js

/* @flow */
/**
 *  Copyright (c) 2015, Facebook, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  LICENSE file in the root directory of this source tree. An additional grant
 *  of patent rights can be found in the PATENTS file in the same directory.
 */

import {
  Source,
  parse,
  validate,
  execute,
  formatError,
  getOperationAST,
  specifiedRules
} from 'graphql';
import httpError from 'http-errors';
import accepts from 'accepts';
import url from 'url';
import querystring from 'querystring';

import { parseBody } from './parseBody';
import { renderGraphiQL } from './renderGraphiQL';

import type { Request, Response } from 'express';


/**
 * Used to configure the graphQLHTTP middleware by providing a schema
 * and other configuration options.
 *
 * Options can be provided as an Object, a Promise for an Object, or a Function
 * that returns an Object or a Promise for an Object.
 */
export type Options = ((request: Request) => OptionsResult) | OptionsResult;
export type OptionsResult = OptionsData | Promise<OptionsData>;
export type OptionsData = {
  /**
   * A GraphQL schema from graphql-js.
   */
  schema: Object,

  /**
   * A value to pass as the context to the graphql() function.
   */
  context?: ?mixed,

  /**
   * An object to pass as the rootValue to the graphql() function.
   */
  rootValue?: ?Object,

  /**
   * A boolean to configure whether the output should be pretty-printed.
   */
  pretty?: ?boolean,

  /**
   * An optional function which will be used to format any errors produced by
   * fulfilling a GraphQL operation. If no function is provided, GraphQL's
   * default spec-compliant `formatError` function will be used.
   */
  formatError?: ?Function,

  /**
   * An optional array of validation rules that will be applied on the document
   * in additional to those defined by the GraphQL spec.
   */
  validationRules?: ?Array<any>,

  /**
   * A boolean to optionally enable GraphiQL mode.
   */
  graphiql?: ?boolean,
};

type Middleware = (request: Request, response: Response) => void;

/**
 * Middleware for express; takes an options object or function as input to
 * configure behavior, and returns an express middleware.
 */
export default function graphqlHTTP(options: Options): Middleware {
  if (!options) {
    throw new Error('GraphQL middleware requires options.');
  }

  return (request: Request, response: Response) => {
    // Higher scoped variables are referred to at various stages in the
    // asyncronous state machine below.
    let schema;
    let context;
    let rootValue;
    let pretty;
    let graphiql;
    let formatErrorFn;
    let showGraphiQL;
    let query;
    let variables;
    let operationName;
    let validationRules;

    // Promises are used as a mechanism for capturing any thrown errors during
    // the asyncronous process below.

    // Resolve the Options to get OptionsData.
    new Promise(resolve => {
      resolve(typeof options === 'function' ? options(request) : options);
    }).then(optionsData => {
      // Assert that optionsData is in fact an Object.
      if (!optionsData || typeof optionsData !== 'object') {
        throw new Error(
          'GraphQL middleware option function must return an options object ' +
          'or a promise which will be resolved to an options object.'
        );
      }

      // Assert that schema is required.
      if (!optionsData.schema) {
        throw new Error(
          'GraphQL middleware options must contain a schema.'
        );
      }

      // Collect information from the options data object.
      schema = optionsData.schema;
      context = optionsData.context;
      rootValue = optionsData.rootValue;
      pretty = optionsData.pretty;
      graphiql = optionsData.graphiql;
      formatErrorFn = optionsData.formatError;

      validationRules = specifiedRules;
      if (optionsData.validationRules) {
        validationRules = validationRules.concat(optionsData.validationRules);
      }

      // GraphQL HTTP only supports GET and POST methods.
      if (request.method !== 'GET' && request.method !== 'POST') {
        response.setHeader('Allow', 'GET, POST');
        throw httpError(405, 'GraphQL only supports GET and POST requests.');
      }

      // Parse the Request body.
      return parseBody(request);
    }).then(data => {
      showGraphiQL = graphiql && canDisplayGraphiQL(request, data);

      // Get GraphQL params from the request and POST body data.
      const params = getGraphQLParams(request, data);
      query = params.query;
      variables = params.variables;
      operationName = params.operationName;

      // If there is no query, but GraphiQL will be displayed, do not produce
      // a result, otherwise return a 400: Bad Request.
      if (!query) {
        if (showGraphiQL) {
          return null;
        }
        throw httpError(400, 'Must provide query string.');
      }

      // GraphQL source.
      const source = new Source(query, 'GraphQL request');

      // Parse source to AST, reporting any syntax error.
      let documentAST;
      try {
        documentAST = parse(source);
      } catch (syntaxError) {
        // Return 400: Bad Request if any syntax errors errors exist.
        response.statusCode = 400;
        return { errors: [ syntaxError ] };
      }

      // Validate AST, reporting any errors.
      const validationErrors = validate(schema, documentAST, validationRules);
      if (validationErrors.length > 0) {
        // Return 400: Bad Request if any validation errors exist.
        response.statusCode = 400;
        return { errors: validationErrors };
      }

      // Only query operations are allowed on GET requests.
      if (request.method === 'GET') {
        // Determine if this GET request will perform a non-query.
        const operationAST = getOperationAST(documentAST, operationName);
        if (operationAST && operationAST.operation !== 'query') {
          // If GraphiQL can be shown, do not perform this query, but
          // provide it to GraphiQL so that the requester may perform it
          // themselves if desired.
          if (showGraphiQL) {
            return null;
          }

          // Otherwise, report a 405: Method Not Allowed error.
          response.setHeader('Allow', 'POST');
          throw httpError(
            405,
            `Can only perform a ${operationAST.operation} operation ` +
            'from a POST request.'
          );
        }
      }
      // Perform the execution, reporting any errors creating the context.
      try {
        return execute(
          schema,
          documentAST,
          rootValue,
          context,
          variables,
          operationName
        );
      } catch (contextError) {
        // Return 400: Bad Request if any execution context errors exist.
        response.statusCode = 400;
        return { errors: [ contextError ] };
      }
    }).catch(error => {
      // If an error was caught, report the httpError status, or 500.
      response.statusCode = error.status || 500;
      return { errors: [ error ] };
    }).then(result => {
      // Format any encountered errors.
      if (result && result.errors) {
        result.errors = result.errors.map(formatErrorFn || formatError);
      }
      // If allowed to show GraphiQL, present it instead of JSON.
      if (showGraphiQL) {
        const data = renderGraphiQL({
          query, variables,
          operationName, result
        });
        response.setHeader('Content-Type', 'text/html');
        response.write(data);
        response.end();
      } else {
        // Otherwise, present JSON directly.
        const data = JSON.stringify(result, null, pretty ? 2 : 0);
        response.setHeader('Content-Type', 'application/json');
        response.write(data);
        response.end();
      }
    });
  };
}

type GraphQLParams = {
  query: ?string;
  variables: ?Object;
  operationName: ?string;
}

/**
 * Helper function to get the GraphQL params from the request.
 */
function getGraphQLParams(request: Request, data: Object): GraphQLParams {
  // GraphQL Query string.
  const query = getQuery(request).query || data.query;

  // Parse the variables if needed.
  let variables = getQuery(request).variables || data.variables;
  if (variables && typeof variables === 'string') {
    try {
      variables = JSON.parse(variables);
    } catch (error) {
      throw httpError(400, 'Variables are invalid JSON.');
    }
  }

  // Name of GraphQL operation to execute.
  const operationName = getQuery(request).operationName || data.operationName;

  return { query, variables, operationName };
}

/**
 * Helper function to determine if GraphiQL can be displayed.
 */
function canDisplayGraphiQL(request: Request, data: Object): boolean {
  // If `raw` exists, GraphiQL mode is not enabled.
  const raw = getQuery(request).raw !== undefined || data.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';
}

function getQuery(request: Request): Object {
  if (request.query) {
    // From the parsed Express query.
    return request.query;
  } else if (request._parsedQuery) {
    // From the pre-parsed query which we might set :)
    return request._parsedQuery;
  } else if (request._parsedUrl) {
    // Parse the query string of the pre-pared URL.
    return (request._parsedQuery = querystring.parse(request._parsedUrl.query));
  }
  // Parse the url and the query string.
  return (request._parsedQuery = url.parse(request.url, true).query || {});
}

1	/* @flow */
2	/**
3	* Copyright (c) 2015, Facebook, Inc.
4	* All rights reserved.
5	*
6	* This source code is licensed under the BSD-style license found in the
7	* LICENSE file in the root directory of this source tree. An additional grant
8	* of patent rights can be found in the PATENTS file in the same directory.
9	*/
10
11	import {
12	Source,
13	parse,
14	validate,
15	execute,
16	formatError,
17	getOperationAST,
18	specifiedRules
19	} from 'graphql';
20	import httpError from 'http-errors';
21	import accepts from 'accepts';
22	import url from 'url';
23	import querystring from 'querystring';
24
25	import { parseBody } from './parseBody';
26	import { renderGraphiQL } from './renderGraphiQL';
27
28	import type { Request, Response } from 'express';
29
30
31	/**
32	* Used to configure the graphQLHTTP middleware by providing a schema
33	* and other configuration options.
34	*
35	* Options can be provided as an Object, a Promise for an Object, or a Function
36	* that returns an Object or a Promise for an Object.
37	*/
38	export type Options = ((request: Request) => OptionsResult) \| OptionsResult;
39	export type OptionsResult = OptionsData \| Promise<OptionsData>;
40	export type OptionsData = {
41	/**
42	* A GraphQL schema from graphql-js.
43	*/
44	schema: Object,
45
46	/**
47	* A value to pass as the context to the graphql() function.
48	*/
49	context?: ?mixed,
50
51	/**
52	* An object to pass as the rootValue to the graphql() function.
53	*/
54	rootValue?: ?Object,
55
56	/**
57	* A boolean to configure whether the output should be pretty-printed.
58	*/
59	pretty?: ?boolean,
60
61	/**
62	* An optional function which will be used to format any errors produced by
63	* fulfilling a GraphQL operation. If no function is provided, GraphQL's
64	* default spec-compliant `formatError` function will be used.
65	*/
66	formatError?: ?Function,
67
68	/**
69	* An optional array of validation rules that will be applied on the document
70	* in additional to those defined by the GraphQL spec.
71	*/
72	validationRules?: ?Array<any>,
73
74	/**
75	* A boolean to optionally enable GraphiQL mode.
76	*/
77	graphiql?: ?boolean,
78	};
79
80	type Middleware = (request: Request, response: Response) => void;
81
82	/**
83	* Middleware for express; takes an options object or function as input to
84	* configure behavior, and returns an express middleware.
85	*/
86	export default function graphqlHTTP(options: Options): Middleware {	1✔
87	if (!options) {	179✔
88	throw new Error('GraphQL middleware requires options.');	1✔
89	}
90
91	return (request: Request, response: Response) => {	178✔
92	// Higher scoped variables are referred to at various stages in the
93	// asyncronous state machine below.
94	let schema;	184✔
95	let context;	184✔
96	let rootValue;	184✔
97	let pretty;	184✔
98	let graphiql;	184✔
99	let formatErrorFn;	184✔
100	let showGraphiQL;	184✔
101	let query;	184✔
102	let variables;	184✔
103	let operationName;	184✔
104	let validationRules;	184✔
105
106	// Promises are used as a mechanism for capturing any thrown errors during
107	// the asyncronous process below.
108
109	// Resolve the Options to get OptionsData.
110	new Promise(resolve => {	184✔
111	resolve(typeof options === 'function' ? options(request) : options);	184✔
112	}).then(optionsData => {
113	// Assert that optionsData is in fact an Object.
114	if (!optionsData \|\| typeof optionsData !== 'object') {	181✔
115	throw new Error(	2✔
116	'GraphQL middleware option function must return an options object ' +
117	'or a promise which will be resolved to an options object.'
118	);
119	}
120
121	// Assert that schema is required.
122	if (!optionsData.schema) {	179✔
123	throw new Error(	2✔
124	'GraphQL middleware options must contain a schema.'
125	);
126	}
127
128	// Collect information from the options data object.
129	schema = optionsData.schema;	177✔
130	context = optionsData.context;	177✔
131	rootValue = optionsData.rootValue;	177✔
132	pretty = optionsData.pretty;	177✔
133	graphiql = optionsData.graphiql;	177✔
134	formatErrorFn = optionsData.formatError;	177✔
135
136	validationRules = specifiedRules;	177✔
137	if (optionsData.validationRules) {	177✔
138	validationRules = validationRules.concat(optionsData.validationRules);	3✔
139	}
140
141	// GraphQL HTTP only supports GET and POST methods.
142	if (request.method !== 'GET' && request.method !== 'POST') {	177✔
143	response.setHeader('Allow', 'GET, POST');	3✔
144	throw httpError(405, 'GraphQL only supports GET and POST requests.');	3✔
145	}
146
147	// Parse the Request body.
148	return parseBody(request);	174✔
149	}).then(data => {
150	showGraphiQL = graphiql && canDisplayGraphiQL(request, data);	159✔
151
152	// Get GraphQL params from the request and POST body data.
153	const params = getGraphQLParams(request, data);	159✔
154	query = params.query;	156✔
155	variables = params.variables;	156✔
156	operationName = params.operationName;	156✔
157
158	// If there is no query, but GraphiQL will be displayed, do not produce
159	// a result, otherwise return a 400: Bad Request.
160	if (!query) {	156✔
161	if (showGraphiQL) {	15✔
162	return null;	3✔
163	}
164	throw httpError(400, 'Must provide query string.');	12✔
165	}
166
167	// GraphQL source.
168	const source = new Source(query, 'GraphQL request');	141✔
169
170	// Parse source to AST, reporting any syntax error.
171	let documentAST;	141✔
172	try {	141✔
173	documentAST = parse(source);	141✔
174	} catch (syntaxError) {
175	// Return 400: Bad Request if any syntax errors errors exist.
176	response.statusCode = 400;	6✔
177	return { errors: [ syntaxError ] };	6✔
178	}
179
180	// Validate AST, reporting any errors.
181	const validationErrors = validate(schema, documentAST, validationRules);	135✔
182	if (validationErrors.length > 0) {	135✔
183	// Return 400: Bad Request if any validation errors exist.
184	response.statusCode = 400;	6✔
185	return { errors: validationErrors };	6✔
186	}
187
188	// Only query operations are allowed on GET requests.
189	if (request.method === 'GET') {	129✔
190	// Determine if this GET request will perform a non-query.
191	const operationAST = getOperationAST(documentAST, operationName);	81✔
192	if (operationAST && operationAST.operation !== 'query') {	81✔
193	// If GraphiQL can be shown, do not perform this query, but
194	// provide it to GraphiQL so that the requester may perform it
195	// themselves if desired.
196	if (showGraphiQL) {	9✔
197	return null;	3✔
198	}
199
200	// Otherwise, report a 405: Method Not Allowed error.
201	response.setHeader('Allow', 'POST');	6✔
202	throw httpError(	6✔
203	405,
204	`Can only perform a ${operationAST.operation} operation ` +
205	'from a POST request.'
206	);
207	}
208	}
209	// Perform the execution, reporting any errors creating the context.
210	try {	120✔
211	return execute(	120✔
212	schema,
213	documentAST,
214	rootValue,
215	context,
216	variables,
217	operationName
218	);
219	} catch (contextError) {
220	// Return 400: Bad Request if any execution context errors exist.
221	response.statusCode = 400;	3✔
222	return { errors: [ contextError ] };	3✔
223	}
224	}).catch(error => {
225	// If an error was caught, report the httpError status, or 500.
226	response.statusCode = error.status \|\| 500;	46✔
227	return { errors: [ error ] };	46✔
228	}).then(result => {
229	// Format any encountered errors.
230	if (result && result.errors) {	184✔
231	result.errors = result.errors.map(formatErrorFn \|\| formatError);	70✔
232	}
233	// If allowed to show GraphiQL, present it instead of JSON.
234	if (showGraphiQL) {	184✔
235	const data = renderGraphiQL({	27✔
236	query, variables,
237	operationName, result
238	});
239	response.setHeader('Content-Type', 'text/html');	27✔
240	response.write(data);	27✔
241	response.end();	27✔
242	} else {
243	// Otherwise, present JSON directly.
244	const data = JSON.stringify(result, null, pretty ? 2 : 0);	157✔
245	response.setHeader('Content-Type', 'application/json');	157✔
246	response.write(data);	157✔
247	response.end();	157✔
248	}
249	});
250	};
251	}
252
253	type GraphQLParams = {
254	query: ?string;
255	variables: ?Object;
256	operationName: ?string;
257	}
258
259	/**
260	* Helper function to get the GraphQL params from the request.
261	*/
262	function getGraphQLParams(request: Request, data: Object): GraphQLParams {	1✔
263	// GraphQL Query string.
264	const query = getQuery(request).query \|\| data.query;	159✔
265
266	// Parse the variables if needed.
267	let variables = getQuery(request).variables \|\| data.variables;	159✔
268	if (variables && typeof variables === 'string') {	159✔
269	try {	30✔
270	variables = JSON.parse(variables);	30✔
271	} catch (error) {
272	throw httpError(400, 'Variables are invalid JSON.');	3✔
273	}
274	}
275
276	// Name of GraphQL operation to execute.
277	const operationName = getQuery(request).operationName \|\| data.operationName;	156✔
278
279	return { query, variables, operationName };	156✔
280	}
281
282	/**
283	* Helper function to determine if GraphiQL can be displayed.
284	*/
285	function canDisplayGraphiQL(request: Request, data: Object): boolean {	1✔
286	// If `raw` exists, GraphiQL mode is not enabled.
287	const raw = getQuery(request).raw !== undefined \|\| data.raw !== undefined;	36✔
288	// Allowed to show GraphiQL if not requested as raw and this request
289	// prefers HTML over JSON.
290	return !raw && accepts(request).types([ 'json', 'html' ]) === 'html';	36✔
291	}
292
293	function getQuery(request: Request): Object {	1✔
294	if (request.query) {	510✔
295	// From the parsed Express query.
296	return request.query;	340✔
297	} else if (request._parsedQuery) {	170✔
298	// From the pre-parsed query which we might set :)
299	return request._parsedQuery;	117✔
300	} else if (request._parsedUrl) {	53✔
301	// Parse the query string of the pre-pared URL.
302	return (request._parsedQuery = querystring.parse(request._parsedUrl.query));	53✔
303	}
304	// Parse the url and the query string.
305	return (request._parsedQuery = url.parse(request.url, true).query \|\| {});	×
306	}

graphql / express-graphql / 197

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous