graphql-http 1.20.0 → 1.22.0

package/lib/handler.mjs

@@ -4,7 +4,7 @@
  *
  */
 import { validate as graphqlValidate, specifiedRules, execute as graphqlExecute, parse as graphqlParse, getOperationAST as graphqlGetOperationAST, GraphQLError, } from 'graphql';
-import { areGraphQLErrors, isAsyncIterable, isExecutionResult, isGraphQLError, isObject, jsonErrorReplacer, } from './utils.mjs';
+import { isAsyncIterable, isExecutionResult, isObject } from './utils.mjs';
 /** Checks whether the passed value is the `graphql-http` server agnostic response. */
 function isResponse(val) {
     // TODO: make sure the contents of init match ResponseInit
@@ -12,6 +12,116 @@ function isResponse(val) {
         (typeof val[0] === 'string' || val[0] === null) &&
         isObject(val[1]));
 }
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ * It parses and validates the request itself, including the request method and the
+ * content-type of the body.
+ *
+ * If the HTTP request itself is invalid or malformed, the function will return an
+ * appropriate {@link Response}.
+ *
+ * If the HTTP request is valid, but is not a well-formatted GraphQL request, the
+ * function will throw an error and it is up to the user to handle and respond as
+ * they see fit.
+ *
+ * @category Server
+ */
+export async function parseRequestParams(req) {
+    var _a, _b;
+    const method = req.method;
+    if (method !== 'GET' && method !== 'POST') {
+        return [
+            null,
+            {
+                status: 405,
+                statusText: 'Method Not Allowed',
+                headers: {
+                    allow: 'GET, POST',
+                },
+            },
+        ];
+    }
+    const [mediaType, charset = 'charset=utf-8', // utf-8 is assumed when not specified. this parameter is either "charset" or "boundary" (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Length)
+    ] = (getHeader(req, 'content-type') || '')
+        .replace(/\s/g, '')
+        .toLowerCase()
+        .split(';');
+    const partParams = {};
+    switch (true) {
+        case method === 'GET': {
+            // TODO: what if content-type is specified and is not application/x-www-form-urlencoded?
+            try {
+                const [, search] = req.url.split('?');
+                const searchParams = new URLSearchParams(search);
+                partParams.operationName =
+                    (_a = searchParams.get('operationName')) !== null && _a !== void 0 ? _a : undefined;
+                partParams.query = (_b = searchParams.get('query')) !== null && _b !== void 0 ? _b : undefined;
+                const variables = searchParams.get('variables');
+                if (variables)
+                    partParams.variables = JSON.parse(variables);
+                const extensions = searchParams.get('extensions');
+                if (extensions)
+                    partParams.extensions = JSON.parse(extensions);
+            }
+            catch (_c) {
+                throw new Error('Unparsable URL');
+            }
+            break;
+        }
+        case method === 'POST' &&
+            mediaType === 'application/json' &&
+            charset === 'charset=utf-8':
+            {
+                if (!req.body) {
+                    throw new Error('Missing body');
+                }
+                let data;
+                try {
+                    const body = typeof req.body === 'function' ? await req.body() : req.body;
+                    data = typeof body === 'string' ? JSON.parse(body) : body;
+                }
+                catch (err) {
+                    throw new Error('Unparsable JSON body');
+                }
+                if (!isObject(data)) {
+                    throw new Error('JSON body must be an object');
+                }
+                partParams.operationName = data.operationName;
+                partParams.query = data.query;
+                partParams.variables = data.variables;
+                partParams.extensions = data.extensions;
+                break;
+            }
+        default: // graphql-http doesnt support any other content type
+            return [
+                null,
+                {
+                    status: 415,
+                    statusText: 'Unsupported Media Type',
+                },
+            ];
+    }
+    if (partParams.query == null)
+        throw new Error('Missing query');
+    if (typeof partParams.query !== 'string')
+        throw new Error('Invalid query');
+    if (partParams.variables != null &&
+        (typeof partParams.variables !== 'object' ||
+            Array.isArray(partParams.variables))) {
+        throw new Error('Invalid variables');
+    }
+    if (partParams.operationName != null &&
+        typeof partParams.operationName !== 'string') {
+        throw new Error('Invalid operationName');
+    }
+    if (partParams.extensions != null &&
+        (typeof partParams.extensions !== 'object' ||
+            Array.isArray(partParams.extensions))) {
+        throw new Error('Invalid extensions');
+    }
+    // request parameters are checked and now complete
+    return partParams;
+}
 /**
  * Makes a GraphQL over HTTP spec compliant server handler. The handler can
  * be used with your favorite server library.
@@ -68,7 +178,7 @@ function isResponse(val) {
  * @category Server
  */
 export function createHandler(options) {
-    const { schema, context, validate = graphqlValidate, validationRules = [], execute = graphqlExecute, parse = graphqlParse, getOperationAST = graphqlGetOperationAST, rootValue, onSubscribe, onOperation, formatError = (err) => err, parseRequestParams = defaultParseRequestParams, } = options;
+    const { schema, context, validate = graphqlValidate, validationRules = [], execute = graphqlExecute, parse = graphqlParse, getOperationAST = graphqlGetOperationAST, rootValue, onSubscribe, onOperation, formatError = (err) => err, parseRequestParams: optionsParseRequestParams = parseRequestParams, } = options;
     return async function handler(req) {
         let acceptedMediaType = null;
         const accepts = (getHeader(req, 'accept') || '*/*')
@@ -108,9 +218,9 @@ export function createHandler(options) {
         }
         let params;
         try {
-            let paramsOrRes = await parseRequestParams(req);
+            let paramsOrRes = await optionsParseRequestParams(req);
             if (!paramsOrRes)
-                paramsOrRes = await defaultParseRequestParams(req);
+                paramsOrRes = await parseRequestParams(req);
             if (isResponse(paramsOrRes))
                 return paramsOrRes;
             params = paramsOrRes;
@@ -218,110 +328,6 @@ export function createHandler(options) {
         return makeResponse(result, acceptedMediaType, formatError);
     };
 }
-/**
- * The default request params parser. Used when no custom one is provided or if it
- * returns nothing.
- *
- * Read more about it in {@link ParseRequestParams}.
- *
- * TODO: should graphql-http itself care about content-encoding? I'd say unzipping should happen before handler is reached
- */
-async function defaultParseRequestParams(req) {
-    var _a, _b;
-    const method = req.method;
-    if (method !== 'GET' && method !== 'POST') {
-        return [
-            null,
-            {
-                status: 405,
-                statusText: 'Method Not Allowed',
-                headers: {
-                    allow: 'GET, POST',
-                },
-            },
-        ];
-    }
-    const [mediaType, charset = 'charset=utf-8', // utf-8 is assumed when not specified. this parameter is either "charset" or "boundary" (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Length)
-    ] = (getHeader(req, 'content-type') || '')
-        .replace(/\s/g, '')
-        .toLowerCase()
-        .split(';');
-    const partParams = {};
-    switch (true) {
-        case method === 'GET': {
-            // TODO: what if content-type is specified and is not application/x-www-form-urlencoded?
-            try {
-                const [, search] = req.url.split('?');
-                const searchParams = new URLSearchParams(search);
-                partParams.operationName =
-                    (_a = searchParams.get('operationName')) !== null && _a !== void 0 ? _a : undefined;
-                partParams.query = (_b = searchParams.get('query')) !== null && _b !== void 0 ? _b : undefined;
-                const variables = searchParams.get('variables');
-                if (variables)
-                    partParams.variables = JSON.parse(variables);
-                const extensions = searchParams.get('extensions');
-                if (extensions)
-                    partParams.extensions = JSON.parse(extensions);
-            }
-            catch (_c) {
-                throw new Error('Unparsable URL');
-            }
-            break;
-        }
-        case method === 'POST' &&
-            mediaType === 'application/json' &&
-            charset === 'charset=utf-8':
-            {
-                if (!req.body) {
-                    throw new Error('Missing body');
-                }
-                let data;
-                try {
-                    const body = typeof req.body === 'function' ? await req.body() : req.body;
-                    data = typeof body === 'string' ? JSON.parse(body) : body;
-                }
-                catch (err) {
-                    throw new Error('Unparsable JSON body');
-                }
-                if (!isObject(data)) {
-                    throw new Error('JSON body must be an object');
-                }
-                partParams.operationName = data.operationName;
-                partParams.query = data.query;
-                partParams.variables = data.variables;
-                partParams.extensions = data.extensions;
-                break;
-            }
-        default: // graphql-http doesnt support any other content type
-            return [
-                null,
-                {
-                    status: 415,
-                    statusText: 'Unsupported Media Type',
-                },
-            ];
-    }
-    if (partParams.query == null)
-        throw new Error('Missing query');
-    if (typeof partParams.query !== 'string')
-        throw new Error('Invalid query');
-    if (partParams.variables != null &&
-        (typeof partParams.variables !== 'object' ||
-            Array.isArray(partParams.variables))) {
-        throw new Error('Invalid variables');
-    }
-    if (partParams.operationName != null &&
-        typeof partParams.operationName !== 'string') {
-        throw new Error('Invalid operationName');
-    }
-    if (partParams.extensions != null &&
-        (typeof partParams.extensions !== 'object' ||
-            Array.isArray(partParams.extensions))) {
-        throw new Error('Invalid extensions');
-    }
-    // request parameters are checked and now complete
-    return partParams;
-}
 /**
  * Creates an appropriate GraphQL over HTTP response following the provided arguments.
  *
@@ -391,3 +397,26 @@ function getHeader(req, key) {
     }
     return Object(req.headers)[key];
 }
+function areGraphQLErrors(obj) {
+    return (Array.isArray(obj) &&
+        obj.length > 0 &&
+        // if one item in the array is a GraphQLError, we're good
+        obj.some(isGraphQLError));
+}
+function isGraphQLError(obj) {
+    return obj instanceof GraphQLError;
+}
+function jsonErrorReplacer(_key, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+val) {
+    if (val instanceof Error &&
+        // GraphQL errors implement their own stringer
+        !isGraphQLError(val)) {
+        return {
+            // name: val.name, name is included in message
+            message: val.message,
+            // stack: val.stack, can leak sensitive details
+        };
+    }
+    return val;
+}

package/lib/use/@netlify/functions.d.mts

@@ -0,0 +1,14 @@
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../../handler/index.mjs';
+import type { Handler as NetlifyHandler, HandlerEvent as NetlifyHandlerEvent, HandlerContext as NetlifyHandlerContext } from '@netlify/functions';
+/**
+ * Handler options when using the netlify adapter
+ *
+ * @category Server/@netlify/functions
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<NetlifyHandlerEvent, NetlifyHandlerContext, Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for netlify functions
+ *
+ * @category Server/@netlify/functions
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>): NetlifyHandler;

package/lib/use/@netlify/functions.d.ts

@@ -0,0 +1,14 @@
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../../handler';
+import type { Handler as NetlifyHandler, HandlerEvent as NetlifyHandlerEvent, HandlerContext as NetlifyHandlerContext } from '@netlify/functions';
+/**
+ * Handler options when using the netlify adapter
+ *
+ * @category Server/@netlify/functions
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<NetlifyHandlerEvent, NetlifyHandlerContext, Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for netlify functions
+ *
+ * @category Server/@netlify/functions
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>): NetlifyHandler;

package/lib/use/@netlify/functions.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHandler = void 0;
+const handler_1 = require("../../handler");
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for netlify functions
+ *
+ * @category Server/@netlify/functions
+ */
+function createHandler(options) {
+    const handler = (0, handler_1.createHandler)(options);
+    return async function handleRequest(req, ctx) {
+        try {
+            const [body, init] = await handler({
+                method: req.httpMethod,
+                url: req.rawUrl,
+                headers: req.headers,
+                body: req.body,
+                raw: req,
+                context: ctx,
+            });
+            return {
+                // if body is null, return undefined
+                body: body !== null && body !== void 0 ? body : undefined,
+                statusCode: init.status,
+            };
+        }
+        catch (err) {
+            // The handler shouldnt throw errors.
+            // If you wish to handle them differently, consider implementing your own request handler.
+            console.error('Internal error occurred during request handling. ' +
+                'Please check your implementation.', err);
+            return { statusCode: 500 };
+        }
+    };
+}
+exports.createHandler = createHandler;

package/lib/use/@netlify/functions.mjs

@@ -0,0 +1,33 @@
+import { createHandler as createRawHandler, } from '../../handler.mjs';
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for netlify functions
+ *
+ * @category Server/@netlify/functions
+ */
+export function createHandler(options) {
+    const handler = createRawHandler(options);
+    return async function handleRequest(req, ctx) {
+        try {
+            const [body, init] = await handler({
+                method: req.httpMethod,
+                url: req.rawUrl,
+                headers: req.headers,
+                body: req.body,
+                raw: req,
+                context: ctx,
+            });
+            return {
+                // if body is null, return undefined
+                body: body !== null && body !== void 0 ? body : undefined,
+                statusCode: init.status,
+            };
+        }
+        catch (err) {
+            // The handler shouldnt throw errors.
+            // If you wish to handle them differently, consider implementing your own request handler.
+            console.error('Internal error occurred during request handling. ' +
+                'Please check your implementation.', err);
+            return { statusCode: 500 };
+        }
+    };
+}

package/lib/use/express.d.mts

@@ -1,5 +1,6 @@
 import type { Request, Response, Handler } from 'express';
 import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler.mjs';
+import { RequestParams } from '../common.mjs';
 /**
  * The context in the request for the handler.
  *
@@ -8,6 +9,46 @@ import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handle
 export interface RequestContext {
     res: Response;
 }
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ *
+ * If the HTTP request _is not_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), the function will respond
+ * on the `Response` argument and return `null`.
+ *
+ * If the HTTP request _is_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), but is invalid or malformed,
+ * the function will throw an error and it is up to the user to handle and respond as they see fit.
+ *
+ * ```js
+ * import express from 'express'; // yarn add express
+ * import { parseRequestParams } from 'graphql-http/lib/use/express';
+ *
+ * const app = express();
+ * app.all('/graphql', async (req, res) => {
+ *   try {
+ *     const maybeParams = await parseRequestParams(req, res);
+ *     if (!maybeParams) {
+ *       // not a well-formatted GraphQL over HTTP request,
+ *       // parser responded and there's nothing else to do
+ *       return;
+ *     }
+ *
+ *     // well-formatted GraphQL over HTTP request,
+ *     // with valid parameters
+ *     res.writeHead(200).end(JSON.stringify(maybeParams, null, '  '));
+ *   } catch (err) {
+ *     // well-formatted GraphQL over HTTP request,
+ *     // but with invalid parameters
+ *     res.writeHead(400).end(err.message);
+ *   }
+ * });
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/express
+ */
+export declare function parseRequestParams(req: Request, res: Response): Promise<RequestParams | null>;
 /**
  * Handler options when using the express adapter.
  *

package/lib/use/express.d.ts

@@ -1,5 +1,6 @@
 import type { Request, Response, Handler } from 'express';
 import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
+import { RequestParams } from '../common';
 /**
  * The context in the request for the handler.
  *
@@ -8,6 +9,46 @@ import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handle
 export interface RequestContext {
     res: Response;
 }
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ *
+ * If the HTTP request _is not_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), the function will respond
+ * on the `Response` argument and return `null`.
+ *
+ * If the HTTP request _is_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), but is invalid or malformed,
+ * the function will throw an error and it is up to the user to handle and respond as they see fit.
+ *
+ * ```js
+ * import express from 'express'; // yarn add express
+ * import { parseRequestParams } from 'graphql-http/lib/use/express';
+ *
+ * const app = express();
+ * app.all('/graphql', async (req, res) => {
+ *   try {
+ *     const maybeParams = await parseRequestParams(req, res);
+ *     if (!maybeParams) {
+ *       // not a well-formatted GraphQL over HTTP request,
+ *       // parser responded and there's nothing else to do
+ *       return;
+ *     }
+ *
+ *     // well-formatted GraphQL over HTTP request,
+ *     // with valid parameters
+ *     res.writeHead(200).end(JSON.stringify(maybeParams, null, '  '));
+ *   } catch (err) {
+ *     // well-formatted GraphQL over HTTP request,
+ *     // but with invalid parameters
+ *     res.writeHead(400).end(err.message);
+ *   }
+ * });
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/express
+ */
+export declare function parseRequestParams(req: Request, res: Response): Promise<RequestParams | null>;
 /**
  * Handler options when using the express adapter.
  *

package/lib/use/express.js

@@ -1,7 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHandler = void 0;
+exports.createHandler = exports.parseRequestParams = void 0;
 const handler_1 = require("../handler");
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ *
+ * If the HTTP request _is not_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), the function will respond
+ * on the `Response` argument and return `null`.
+ *
+ * If the HTTP request _is_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), but is invalid or malformed,
+ * the function will throw an error and it is up to the user to handle and respond as they see fit.
+ *
+ * ```js
+ * import express from 'express'; // yarn add express
+ * import { parseRequestParams } from 'graphql-http/lib/use/express';
+ *
+ * const app = express();
+ * app.all('/graphql', async (req, res) => {
+ *   try {
+ *     const maybeParams = await parseRequestParams(req, res);
+ *     if (!maybeParams) {
+ *       // not a well-formatted GraphQL over HTTP request,
+ *       // parser responded and there's nothing else to do
+ *       return;
+ *     }
+ *
+ *     // well-formatted GraphQL over HTTP request,
+ *     // with valid parameters
+ *     res.writeHead(200).end(JSON.stringify(maybeParams, null, '  '));
+ *   } catch (err) {
+ *     // well-formatted GraphQL over HTTP request,
+ *     // but with invalid parameters
+ *     res.writeHead(400).end(err.message);
+ *   }
+ * });
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/express
+ */
+async function parseRequestParams(req, res) {
+    const rawReq = toRequest(req, res);
+    const paramsOrRes = await (0, handler_1.parseRequestParams)(rawReq);
+    if (!('query' in paramsOrRes)) {
+        const [body, init] = paramsOrRes;
+        res.writeHead(init.status, init.statusText, init.headers).end(body);
+        return null;
+    }
+    return paramsOrRes;
+}
+exports.parseRequestParams = parseRequestParams;
 /**
  * Create a GraphQL over HTTP spec compliant request handler for
  * the express framework.
@@ -24,24 +74,7 @@ function createHandler(options) {
     const handle = (0, handler_1.createHandler)(options);
     return async function requestListener(req, res) {
         try {
-            const [body, init] = await handle({
-                url: req.url,
-                method: req.method,
-                headers: req.headers,
-                body: () => {
-                    if (req.body) {
-                        // in case express has a body parser
-                        return req.body;
-                    }
-                    return new Promise((resolve) => {
-                        let body = '';
-                        req.on('data', (chunk) => (body += chunk));
-                        req.on('end', () => resolve(body));
-                    });
-                },
-                raw: req,
-                context: { res },
-            });
+            const [body, init] = await handle(toRequest(req, res));
             res.writeHead(init.status, init.statusText, init.headers).end(body);
         }
         catch (err) {
@@ -54,3 +87,23 @@ function createHandler(options) {
     };
 }
 exports.createHandler = createHandler;
+function toRequest(req, res) {
+    return {
+        url: req.url,
+        method: req.method,
+        headers: req.headers,
+        body: () => {
+            if (req.body) {
+                // in case express has a body parser
+                return req.body;
+            }
+            return new Promise((resolve) => {
+                let body = '';
+                req.on('data', (chunk) => (body += chunk));
+                req.on('end', () => resolve(body));
+            });
+        },
+        raw: req,
+        context: { res },
+    };
+}