graphql-http 1.21.0 → 1.22.1

package/lib/use/koa.d.mts

@@ -1,7 +1,8 @@
 /// <reference types="node" />
-import type { Middleware, Response } from 'koa';
+import type { Middleware, ParameterizedContext, Response } from 'koa';
 import type { IncomingMessage } from 'http';
 import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler.mjs';
+import { RequestParams } from '../common.mjs';
 /**
  * The context in the request for the handler.
  *
@@ -10,6 +11,51 @@ 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 Koa's `ParameterizedContext` response 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 Koa from 'koa'; // yarn add koa
+ * import mount from 'koa-mount'; // yarn add koa-mount
+ * import { parseRequestParams } from 'graphql-http/lib/use/koa';
+ *
+ * const app = new Koa();
+ * app.use(
+ *   mount('/', async (ctx) => {
+ *     try {
+ *       const maybeParams = await parseRequestParams(ctx);
+ *       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
+ *       ctx.response.status = 200;
+ *       ctx.body = JSON.stringify(maybeParams, null, '  ');
+ *     } catch (err) {
+ *       // well-formatted GraphQL over HTTP request,
+ *       // but with invalid parameters
+ *       ctx.response.status = 400;
+ *       ctx.body = err.message;
+ *     }
+ *   }),
+ * );
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/koa
+ */
+export declare function parseRequestParams(ctx: ParameterizedContext): Promise<RequestParams | null>;
 /**
  * Handler options when using the koa adapter.
  *

package/lib/use/koa.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="node" />
-import type { Middleware, Response } from 'koa';
+import type { Middleware, ParameterizedContext, Response } from 'koa';
 import type { IncomingMessage } from 'http';
 import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
+import { RequestParams } from '../common';
 /**
  * The context in the request for the handler.
  *
@@ -10,6 +11,51 @@ 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 Koa's `ParameterizedContext` response 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 Koa from 'koa'; // yarn add koa
+ * import mount from 'koa-mount'; // yarn add koa-mount
+ * import { parseRequestParams } from 'graphql-http/lib/use/koa';
+ *
+ * const app = new Koa();
+ * app.use(
+ *   mount('/', async (ctx) => {
+ *     try {
+ *       const maybeParams = await parseRequestParams(ctx);
+ *       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
+ *       ctx.response.status = 200;
+ *       ctx.body = JSON.stringify(maybeParams, null, '  ');
+ *     } catch (err) {
+ *       // well-formatted GraphQL over HTTP request,
+ *       // but with invalid parameters
+ *       ctx.response.status = 400;
+ *       ctx.body = err.message;
+ *     }
+ *   }),
+ * );
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/koa
+ */
+export declare function parseRequestParams(ctx: ParameterizedContext): Promise<RequestParams | null>;
 /**
  * Handler options when using the koa adapter.
  *

package/lib/use/koa.js

@@ -1,7 +1,69 @@
 "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 Koa's `ParameterizedContext` response 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 Koa from 'koa'; // yarn add koa
+ * import mount from 'koa-mount'; // yarn add koa-mount
+ * import { parseRequestParams } from 'graphql-http/lib/use/koa';
+ *
+ * const app = new Koa();
+ * app.use(
+ *   mount('/', async (ctx) => {
+ *     try {
+ *       const maybeParams = await parseRequestParams(ctx);
+ *       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
+ *       ctx.response.status = 200;
+ *       ctx.body = JSON.stringify(maybeParams, null, '  ');
+ *     } catch (err) {
+ *       // well-formatted GraphQL over HTTP request,
+ *       // but with invalid parameters
+ *       ctx.response.status = 400;
+ *       ctx.body = err.message;
+ *     }
+ *   }),
+ * );
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/koa
+ */
+async function parseRequestParams(ctx) {
+    const rawReq = toRequest(ctx);
+    const paramsOrRes = await (0, handler_1.parseRequestParams)(rawReq);
+    if (!('query' in paramsOrRes)) {
+        const [body, init] = paramsOrRes;
+        ctx.body = body;
+        ctx.response.status = init.status;
+        ctx.response.message = init.statusText;
+        if (init.headers) {
+            for (const [name, value] of Object.entries(init.headers)) {
+                ctx.response.set(name, value);
+            }
+        }
+        return null;
+    }
+    return paramsOrRes;
+}
+exports.parseRequestParams = parseRequestParams;
 /**
  * Create a GraphQL over HTTP spec compliant request handler for
  * the Koa framework.
@@ -36,6 +98,7 @@ function createHandler(options) {
                     }
                     return new Promise((resolve) => {
                         let body = '';
+                        ctx.req.setEncoding('utf-8');
                         ctx.req.on('data', (chunk) => (body += chunk));
                         ctx.req.on('end', () => resolve(body));
                     });
@@ -62,3 +125,24 @@ function createHandler(options) {
     };
 }
 exports.createHandler = createHandler;
+function toRequest(ctx) {
+    return {
+        url: ctx.url,
+        method: ctx.method,
+        headers: ctx.headers,
+        body: () => {
+            if (ctx.body) {
+                // in case koa has a body parser
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return ctx.body;
+            }
+            return new Promise((resolve) => {
+                let body = '';
+                ctx.req.on('data', (chunk) => (body += chunk));
+                ctx.req.on('end', () => resolve(body));
+            });
+        },
+        raw: ctx.req,
+        context: { res: ctx.response },
+    };
+}

package/lib/use/koa.mjs

@@ -1,4 +1,65 @@
-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 Koa's `ParameterizedContext` response 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 Koa from 'koa'; // yarn add koa
+ * import mount from 'koa-mount'; // yarn add koa-mount
+ * import { parseRequestParams } from 'graphql-http/lib/use/koa';
+ *
+ * const app = new Koa();
+ * app.use(
+ *   mount('/', async (ctx) => {
+ *     try {
+ *       const maybeParams = await parseRequestParams(ctx);
+ *       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
+ *       ctx.response.status = 200;
+ *       ctx.body = JSON.stringify(maybeParams, null, '  ');
+ *     } catch (err) {
+ *       // well-formatted GraphQL over HTTP request,
+ *       // but with invalid parameters
+ *       ctx.response.status = 400;
+ *       ctx.body = err.message;
+ *     }
+ *   }),
+ * );
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/koa
+ */
+export async function parseRequestParams(ctx) {
+    const rawReq = toRequest(ctx);
+    const paramsOrRes = await rawParseRequestParams(rawReq);
+    if (!('query' in paramsOrRes)) {
+        const [body, init] = paramsOrRes;
+        ctx.body = body;
+        ctx.response.status = init.status;
+        ctx.response.message = init.statusText;
+        if (init.headers) {
+            for (const [name, value] of Object.entries(init.headers)) {
+                ctx.response.set(name, value);
+            }
+        }
+        return null;
+    }
+    return paramsOrRes;
+}
 /**
  * Create a GraphQL over HTTP spec compliant request handler for
  * the Koa framework.
@@ -33,6 +94,7 @@ export function createHandler(options) {
                     }
                     return new Promise((resolve) => {
                         let body = '';
+                        ctx.req.setEncoding('utf-8');
                         ctx.req.on('data', (chunk) => (body += chunk));
                         ctx.req.on('end', () => resolve(body));
                     });
@@ -58,3 +120,24 @@ export function createHandler(options) {
         }
     };
 }
+function toRequest(ctx) {
+    return {
+        url: ctx.url,
+        method: ctx.method,
+        headers: ctx.headers,
+        body: () => {
+            if (ctx.body) {
+                // in case koa has a body parser
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return ctx.body;
+            }
+            return new Promise((resolve) => {
+                let body = '';
+                ctx.req.on('data', (chunk) => (body += chunk));
+                ctx.req.on('end', () => resolve(body));
+            });
+        },
+        raw: ctx.req,
+        context: { res: ctx.response },
+    };
+}

package/lib/use/uWebSockets.d.mts

@@ -1,5 +1,6 @@
 import type { HttpRequest, HttpResponse } from 'uWebSockets.js';
 import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler.mjs';
+import { RequestParams } from '../common.mjs';
 /**
  * The context in the request for the handler.
  *
@@ -8,6 +9,60 @@ import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handle
 export interface RequestContext {
     res: HttpResponse;
 }
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ *
+ * It is important to pass in the `abortedRef` so that the parser does not perform any
+ * operations on a disposed request (see example).
+ *
+ * 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 `HttpResponse` 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 uWS from 'uWebSockets.js'; // yarn add uWebSockets.js@uNetworking/uWebSockets.js#<version>
+ * import { parseRequestParams } from 'graphql-http/lib/use/uWebSockets';
+ *
+ * uWS
+ *   .App()
+ *   .any('/graphql', async (res, req) => {
+ *     const abortedRef = { current: false };
+ *     res.onAborted(() => (abortedRef.current = true));
+ *     try {
+ *       const maybeParams = await parseRequestParams(req, res, abortedRef);
+ *       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
+ *       if (!abortedRef.current) {
+ *         res.writeStatus('200 OK');
+ *         res.end(JSON.stringify(maybeParams, null, '  '));
+ *       }
+ *     } catch (err) {
+ *       // well-formatted GraphQL over HTTP request,
+ *       // but with invalid parameters
+ *       if (!abortedRef.current) {
+ *         res.writeStatus('400 Bad Request');
+ *         res.end(err.message);
+ *       }
+ *     }
+ *   })
+ *   .listen(4000, () => {
+ *     console.log('Listening to port 4000');
+ *   });
+ * ```
+ *
+ * @category Server/uWebSockets
+ */
+export declare function parseRequestParams(req: HttpRequest, res: HttpResponse, abortedRef: {
+    current: boolean;
+}): Promise<RequestParams | null>;
 /**
  * Handler options when using the http adapter.
  *

package/lib/use/uWebSockets.d.ts

@@ -1,5 +1,6 @@
 import type { HttpRequest, HttpResponse } from 'uWebSockets.js';
 import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
+import { RequestParams } from '../common';
 /**
  * The context in the request for the handler.
  *
@@ -8,6 +9,60 @@ import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handle
 export interface RequestContext {
     res: HttpResponse;
 }
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ *
+ * It is important to pass in the `abortedRef` so that the parser does not perform any
+ * operations on a disposed request (see example).
+ *
+ * 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 `HttpResponse` 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 uWS from 'uWebSockets.js'; // yarn add uWebSockets.js@uNetworking/uWebSockets.js#<version>
+ * import { parseRequestParams } from 'graphql-http/lib/use/uWebSockets';
+ *
+ * uWS
+ *   .App()
+ *   .any('/graphql', async (res, req) => {
+ *     const abortedRef = { current: false };
+ *     res.onAborted(() => (abortedRef.current = true));
+ *     try {
+ *       const maybeParams = await parseRequestParams(req, res, abortedRef);
+ *       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
+ *       if (!abortedRef.current) {
+ *         res.writeStatus('200 OK');
+ *         res.end(JSON.stringify(maybeParams, null, '  '));
+ *       }
+ *     } catch (err) {
+ *       // well-formatted GraphQL over HTTP request,
+ *       // but with invalid parameters
+ *       if (!abortedRef.current) {
+ *         res.writeStatus('400 Bad Request');
+ *         res.end(err.message);
+ *       }
+ *     }
+ *   })
+ *   .listen(4000, () => {
+ *     console.log('Listening to port 4000');
+ *   });
+ * ```
+ *
+ * @category Server/uWebSockets
+ */
+export declare function parseRequestParams(req: HttpRequest, res: HttpResponse, abortedRef: {
+    current: boolean;
+}): Promise<RequestParams | null>;
 /**
  * Handler options when using the http adapter.
  *

package/lib/use/uWebSockets.js

@@ -1,7 +1,82 @@
 "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.
+ *
+ * It is important to pass in the `abortedRef` so that the parser does not perform any
+ * operations on a disposed request (see example).
+ *
+ * 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 `HttpResponse` 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 uWS from 'uWebSockets.js'; // yarn add uWebSockets.js@uNetworking/uWebSockets.js#<version>
+ * import { parseRequestParams } from 'graphql-http/lib/use/uWebSockets';
+ *
+ * uWS
+ *   .App()
+ *   .any('/graphql', async (res, req) => {
+ *     const abortedRef = { current: false };
+ *     res.onAborted(() => (abortedRef.current = true));
+ *     try {
+ *       const maybeParams = await parseRequestParams(req, res, abortedRef);
+ *       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
+ *       if (!abortedRef.current) {
+ *         res.writeStatus('200 OK');
+ *         res.end(JSON.stringify(maybeParams, null, '  '));
+ *       }
+ *     } catch (err) {
+ *       // well-formatted GraphQL over HTTP request,
+ *       // but with invalid parameters
+ *       if (!abortedRef.current) {
+ *         res.writeStatus('400 Bad Request');
+ *         res.end(err.message);
+ *       }
+ *     }
+ *   })
+ *   .listen(4000, () => {
+ *     console.log('Listening to port 4000');
+ *   });
+ * ```
+ *
+ * @category Server/uWebSockets
+ */
+async function parseRequestParams(req, res, abortedRef) {
+    const rawReq = toRequest(req, res, abortedRef);
+    const paramsOrRes = await (0, handler_1.parseRequestParams)(rawReq);
+    if (!('query' in paramsOrRes)) {
+        if (!abortedRef.current) {
+            const [body, init] = paramsOrRes;
+            res.cork(() => {
+                res.writeStatus(`${init.status} ${init.statusText}`);
+                for (const [key, val] of Object.entries(init.headers || {})) {
+                    res.writeHeader(key, val);
+                }
+                if (body) {
+                    res.end(body);
+                }
+                else {
+                    res.endWithoutBody();
+                }
+            });
+        }
+        return null;
+    }
+    return paramsOrRes;
+}
+exports.parseRequestParams = parseRequestParams;
 /**
  * Create a GraphQL over HTTP spec compliant request handler for
  * the Node environment [uWebSockets.js module](https://github.com/uNetworking/uWebSockets.js/).
@@ -24,36 +99,11 @@ const handler_1 = require("../handler");
 function createHandler(options) {
     const handle = (0, handler_1.createHandler)(options);
     return async function requestListener(res, req) {
-        let aborted = false;
-        res.onAborted(() => (aborted = true));
+        const abortedRef = { current: false };
+        res.onAborted(() => (abortedRef.current = true));
         try {
-            let url = req.getUrl();
-            const query = req.getQuery();
-            if (query) {
-                url += '?' + query;
-            }
-            const [body, init] = await handle({
-                url,
-                method: req.getMethod().toUpperCase(),
-                headers: { get: (key) => req.getHeader(key) },
-                body: () => new Promise((resolve) => {
-                    let body = '';
-                    if (aborted) {
-                        resolve(body);
-                    }
-                    else {
-                        res.onData((chunk, isLast) => {
-                            body += Buffer.from(chunk, 0, chunk.byteLength).toString();
-                            if (isLast) {
-                                resolve(body);
-                            }
-                        });
-                    }
-                }),
-                raw: req,
-                context: { res },
-            });
-            if (!aborted) {
+            const [body, init] = await handle(toRequest(req, res, abortedRef));
+            if (!abortedRef.current) {
                 res.cork(() => {
                     res.writeStatus(`${init.status} ${init.statusText}`);
                     for (const [key, val] of Object.entries(init.headers || {})) {
@@ -73,7 +123,7 @@ function createHandler(options) {
             // 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);
-            if (!aborted) {
+            if (!abortedRef.current) {
                 res.cork(() => {
                     res.writeStatus('500 Internal Server Error').endWithoutBody();
                 });
@@ -82,3 +132,31 @@ function createHandler(options) {
     };
 }
 exports.createHandler = createHandler;
+function toRequest(req, res, abortedRef) {
+    let url = req.getUrl();
+    const query = req.getQuery();
+    if (query) {
+        url += '?' + query;
+    }
+    return {
+        url,
+        method: req.getMethod().toUpperCase(),
+        headers: { get: (key) => req.getHeader(key) },
+        body: () => new Promise((resolve) => {
+            let body = '';
+            if (abortedRef.current) {
+                resolve(body);
+            }
+            else {
+                res.onData((chunk, isLast) => {
+                    body += Buffer.from(chunk, 0, chunk.byteLength).toString();
+                    if (isLast) {
+                        resolve(body);
+                    }
+                });
+            }
+        }),
+        raw: req,
+        context: { res },
+    };
+}