graphql-http 1.21.0 → 1.22.1

package/lib/use/http.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import type { IncomingMessage, ServerResponse } from 'http';
 import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
+import { RequestParams } from '../common';
 /**
  * The context in the request for the handler.
  *
@@ -9,6 +10,49 @@ import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handle
 export interface RequestContext {
     res: ServerResponse;
 }
+/**
+ * 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 `ServerResponse` 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 http from 'http';
+ * import { parseRequestParams } from 'graphql-http/lib/use/http';
+ *
+ * const server = http.createServer(async (req, res) => {
+ *   if (req.url.startsWith('/graphql')) {
+ *     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);
+ *     }
+ *   } else {
+ *     res.writeHead(404).end();
+ *   }
+ * });
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/http
+ */
+export declare function parseRequestParams(req: IncomingMessage, res: ServerResponse): Promise<RequestParams | null>;
 /**
  * Handler options when using the http adapter.
  *

package/lib/use/http.js

@@ -1,7 +1,60 @@
 "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 `ServerResponse` 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 http from 'http';
+ * import { parseRequestParams } from 'graphql-http/lib/use/http';
+ *
+ * const server = http.createServer(async (req, res) => {
+ *   if (req.url.startsWith('/graphql')) {
+ *     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);
+ *     }
+ *   } else {
+ *     res.writeHead(404).end();
+ *   }
+ * });
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/http
+ */
+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 Node environment http module.
@@ -29,18 +82,7 @@ function createHandler(options) {
             if (!req.method) {
                 throw new Error('Missing request method');
             }
-            const [body, init] = await handle({
-                url: req.url,
-                method: req.method,
-                headers: req.headers,
-                body: () => 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) {
@@ -53,3 +95,24 @@ function createHandler(options) {
     };
 }
 exports.createHandler = createHandler;
+function toRequest(req, res) {
+    if (!req.url) {
+        throw new Error('Missing request URL');
+    }
+    if (!req.method) {
+        throw new Error('Missing request method');
+    }
+    return {
+        url: req.url,
+        method: req.method,
+        headers: req.headers,
+        body: () => 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/http.mjs

@@ -1,4 +1,56 @@
-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 `ServerResponse` 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 http from 'http';
+ * import { parseRequestParams } from 'graphql-http/lib/use/http';
+ *
+ * const server = http.createServer(async (req, res) => {
+ *   if (req.url.startsWith('/graphql')) {
+ *     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);
+ *     }
+ *   } else {
+ *     res.writeHead(404).end();
+ *   }
+ * });
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/http
+ */
+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 Node environment http module.
@@ -26,18 +78,7 @@ export function createHandler(options) {
             if (!req.method) {
                 throw new Error('Missing request method');
             }
-            const [body, init] = await handle({
-                url: req.url,
-                method: req.method,
-                headers: req.headers,
-                body: () => 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) {
@@ -49,3 +90,24 @@ export function createHandler(options) {
         }
     };
 }
+function toRequest(req, res) {
+    if (!req.url) {
+        throw new Error('Missing request URL');
+    }
+    if (!req.method) {
+        throw new Error('Missing request method');
+    }
+    return {
+        url: req.url,
+        method: req.method,
+        headers: req.headers,
+        body: () => 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/http2.d.mts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import type { Http2ServerRequest, Http2ServerResponse } from 'http2';
 import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler.mjs';
+import { RequestParams } from '../common.mjs';
 /**
  * The context in the request for the handler.
  *
@@ -9,6 +10,61 @@ import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handle
 export interface RequestContext {
     res: Http2ServerResponse;
 }
+/**
+ * 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 `Http2ServerResponse` 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.
+ *
+ *  ```shell
+ * $ openssl req -x509 -newkey rsa:2048 -nodes -sha256 -subj '/CN=localhost' \
+ *   -keyout localhost-privkey.pem -out localhost-cert.pem
+ * ```
+ *
+ * ```js
+ * import fs from 'fs';
+ * import http2 from 'http2';
+ * import { parseRequestParams } from 'graphql-http/lib/use/http2';
+ *
+ * const server = http2.createSecureServer(
+ *   {
+ *     key: fs.readFileSync('localhost-privkey.pem'),
+ *     cert: fs.readFileSync('localhost-cert.pem'),
+ *   },
+ *   async (req, res) => {
+ *     if (req.url.startsWith('/graphql')) {
+ *       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);
+ *       }
+ *     } else {
+ *       res.writeHead(404).end();
+ *     }
+ *   },
+ * );
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/http2
+ */
+export declare function parseRequestParams(req: Http2ServerRequest, res: Http2ServerResponse): Promise<RequestParams | null>;
 /**
  * Handler options when using the http adapter.
  *

package/lib/use/http2.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import type { Http2ServerRequest, Http2ServerResponse } from 'http2';
 import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
+import { RequestParams } from '../common';
 /**
  * The context in the request for the handler.
  *
@@ -9,6 +10,61 @@ import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handle
 export interface RequestContext {
     res: Http2ServerResponse;
 }
+/**
+ * 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 `Http2ServerResponse` 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.
+ *
+ *  ```shell
+ * $ openssl req -x509 -newkey rsa:2048 -nodes -sha256 -subj '/CN=localhost' \
+ *   -keyout localhost-privkey.pem -out localhost-cert.pem
+ * ```
+ *
+ * ```js
+ * import fs from 'fs';
+ * import http2 from 'http2';
+ * import { parseRequestParams } from 'graphql-http/lib/use/http2';
+ *
+ * const server = http2.createSecureServer(
+ *   {
+ *     key: fs.readFileSync('localhost-privkey.pem'),
+ *     cert: fs.readFileSync('localhost-cert.pem'),
+ *   },
+ *   async (req, res) => {
+ *     if (req.url.startsWith('/graphql')) {
+ *       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);
+ *       }
+ *     } else {
+ *       res.writeHead(404).end();
+ *     }
+ *   },
+ * );
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/http2
+ */
+export declare function parseRequestParams(req: Http2ServerRequest, res: Http2ServerResponse): Promise<RequestParams | null>;
 /**
  * Handler options when using the http adapter.
  *

package/lib/use/http2.js

@@ -1,7 +1,78 @@
 "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 `Http2ServerResponse` 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.
+ *
+ *  ```shell
+ * $ openssl req -x509 -newkey rsa:2048 -nodes -sha256 -subj '/CN=localhost' \
+ *   -keyout localhost-privkey.pem -out localhost-cert.pem
+ * ```
+ *
+ * ```js
+ * import fs from 'fs';
+ * import http2 from 'http2';
+ * import { parseRequestParams } from 'graphql-http/lib/use/http2';
+ *
+ * const server = http2.createSecureServer(
+ *   {
+ *     key: fs.readFileSync('localhost-privkey.pem'),
+ *     cert: fs.readFileSync('localhost-cert.pem'),
+ *   },
+ *   async (req, res) => {
+ *     if (req.url.startsWith('/graphql')) {
+ *       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);
+ *       }
+ *     } else {
+ *       res.writeHead(404).end();
+ *     }
+ *   },
+ * );
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/http2
+ */
+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);
+        if (body) {
+            res.end(body);
+        }
+        else {
+            res.end();
+        }
+        return null;
+    }
+    return paramsOrRes;
+}
+exports.parseRequestParams = parseRequestParams;
 /**
  * Create a GraphQL over HTTP spec compliant request handler for
  * the Node environment http2 module.
@@ -41,18 +112,7 @@ function createHandler(options) {
             if (!req.method) {
                 throw new Error('Missing request method');
             }
-            const [body, init] = await handle({
-                url: req.url,
-                method: req.method,
-                headers: req.headers,
-                body: () => 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);
             if (body) {
                 res.end(body);
@@ -71,3 +131,24 @@ function createHandler(options) {
     };
 }
 exports.createHandler = createHandler;
+function toRequest(req, res) {
+    if (!req.url) {
+        throw new Error('Missing request URL');
+    }
+    if (!req.method) {
+        throw new Error('Missing request method');
+    }
+    return {
+        url: req.url,
+        method: req.method,
+        headers: req.headers,
+        body: () => 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/http2.mjs

@@ -1,4 +1,74 @@
-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 `Http2ServerResponse` 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.
+ *
+ *  ```shell
+ * $ openssl req -x509 -newkey rsa:2048 -nodes -sha256 -subj '/CN=localhost' \
+ *   -keyout localhost-privkey.pem -out localhost-cert.pem
+ * ```
+ *
+ * ```js
+ * import fs from 'fs';
+ * import http2 from 'http2';
+ * import { parseRequestParams } from 'graphql-http/lib/use/http2';
+ *
+ * const server = http2.createSecureServer(
+ *   {
+ *     key: fs.readFileSync('localhost-privkey.pem'),
+ *     cert: fs.readFileSync('localhost-cert.pem'),
+ *   },
+ *   async (req, res) => {
+ *     if (req.url.startsWith('/graphql')) {
+ *       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);
+ *       }
+ *     } else {
+ *       res.writeHead(404).end();
+ *     }
+ *   },
+ * );
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/http2
+ */
+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);
+        if (body) {
+            res.end(body);
+        }
+        else {
+            res.end();
+        }
+        return null;
+    }
+    return paramsOrRes;
+}
 /**
  * Create a GraphQL over HTTP spec compliant request handler for
  * the Node environment http2 module.
@@ -38,18 +108,7 @@ export function createHandler(options) {
             if (!req.method) {
                 throw new Error('Missing request method');
             }
-            const [body, init] = await handle({
-                url: req.url,
-                method: req.method,
-                headers: req.headers,
-                body: () => 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);
             if (body) {
                 res.end(body);
@@ -67,3 +126,24 @@ export function createHandler(options) {
         }
     };
 }
+function toRequest(req, res) {
+    if (!req.url) {
+        throw new Error('Missing request URL');
+    }
+    if (!req.method) {
+        throw new Error('Missing request method');
+    }
+    return {
+        url: req.url,
+        method: req.method,
+        headers: req.headers,
+        body: () => new Promise((resolve) => {
+            let body = '';
+            req.setEncoding('utf-8');
+            req.on('data', (chunk) => (body += chunk));
+            req.on('end', () => resolve(body));
+        }),
+        raw: req,
+        context: { res },
+    };
+}