graphql-http 1.21.0 → 1.22.1

package/lib/handler.mjs

@@ -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') || '*/*')
@@ -79,9 +189,9 @@ export function createHandler(options) {
             // accept-charset became obsolete, shouldnt be used (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Charset)
             // TODO: handle the weight parameter "q"
             const [mediaType, ...params] = accept.split(';');
-            const charset = (params === null || params === void 0 ? void 0 : params.find((param) => param.includes('charset='))) || 'charset=utf8'; // utf-8 is assumed when not specified;
+            const charset = (params === null || params === void 0 ? void 0 : params.find((param) => param.includes('charset='))) || 'charset=utf-8'; // utf-8 is assumed when not specified;
             if (mediaType === 'application/graphql-response+json' &&
-                charset === 'charset=utf8') {
+                charset === 'charset=utf-8') {
                 acceptedMediaType = 'application/graphql-response+json';
                 break;
             }
@@ -89,7 +199,7 @@ export function createHandler(options) {
             if ((mediaType === 'application/json' ||
                 mediaType === 'application/*' ||
                 mediaType === '*/*') &&
-                charset === 'charset=utf8') {
+                (charset === 'charset=utf-8' || charset === 'charset=utf8')) {
                 acceptedMediaType = 'application/json';
                 break;
             }
@@ -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.
  *

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,24 @@ 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.setEncoding('utf-8');
+                req.on('data', (chunk) => (body += chunk));
+                req.on('end', () => resolve(body));
+            });
+        },
+        raw: req,
+        context: { res },
+    };
+}

package/lib/use/express.mjs

@@ -1,4 +1,53 @@
-import { createHandler as createRawHandler, } from '../handler.mjs';
+import { createHandler as createRawHandler, parseRequestParams as rawParseRequestParams, } from '../handler.mjs';
+/**
+ * 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 async function parseRequestParams(req, res) {
+    const rawReq = toRequest(req, res);
+    const paramsOrRes = await rawParseRequestParams(rawReq);
+    if (!('query' in paramsOrRes)) {
+        const [body, init] = paramsOrRes;
+        res.writeHead(init.status, init.statusText, init.headers).end(body);
+        return null;
+    }
+    return paramsOrRes;
+}
 /**
  * Create a GraphQL over HTTP spec compliant request handler for
  * the express framework.
@@ -21,24 +70,7 @@ export function createHandler(options) {
     const handle = createRawHandler(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) {
@@ -50,3 +82,24 @@ export function createHandler(options) {
         }
     };
 }
+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.setEncoding('utf-8');
+                req.on('data', (chunk) => (body += chunk));
+                req.on('end', () => resolve(body));
+            });
+        },
+        raw: req,
+        context: { res },
+    };
+}

package/lib/use/fastify.d.mts

@@ -1,5 +1,6 @@
 import type { FastifyRequest, FastifyReply, RouteHandler } from 'fastify';
 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 {
     reply: FastifyReply;
 }
+/**
+ * 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 `FastifyReply` 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 Fastify from 'fastify'; // yarn add fastify
+ * import { parseRequestParams } from 'graphql-http/lib/use/fastify';
+ *
+ * const fastify = Fastify();
+ * fastify.all('/graphql', async (req, reply) => {
+ *   try {
+ *     const maybeParams = await parseRequestParams(req, reply);
+ *     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
+ *     reply.status(200).send(JSON.stringify(maybeParams, null, '  '));
+ *   } catch (err) {
+ *     // well-formatted GraphQL over HTTP request,
+ *     // but with invalid parameters
+ *     reply.status(400).send(err.message);
+ *   }
+ * });
+ *
+ * fastify.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/fastify
+ */
+export declare function parseRequestParams(req: FastifyRequest, reply: FastifyReply): Promise<RequestParams | null>;
 /**
  * Handler options when using the fastify adapter.
  *
@@ -20,7 +61,7 @@ export type HandlerOptions<Context extends OperationContext = undefined> = RawHa
  *
  * ```js
  * import Fastify from 'fastify'; // yarn add fastify
- * import { createHandler } from 'graphql-http/lib/use/express';
+ * import { createHandler } from 'graphql-http/lib/use/fastify';
  * import { schema } from './my-graphql-schema/index.mjs';
  *
  * const fastify = Fastify();