graphql-http 1.15.0 → 1.17.0

package/lib/use/http.js

@@ -0,0 +1,72 @@
+"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
+ * the Node environment http module.
+ *
+ * ```js
+ * import http from 'http';
+ * import { createHandler } from 'graphql-http/lib/use/http';
+ * import { schema } from './my-graphql-step';
+ *
+ * const server = http.createServer(createHandler({ schema }));
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/http
+ */
+function createHandler(options) {
+    const isProd = process.env.NODE_ENV === 'production';
+    const handle = (0, handler_1.createHandler)(options);
+    return async function requestListener(req, res) {
+        try {
+            if (!req.url) {
+                throw new Error('Missing request URL');
+            }
+            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 },
+            });
+            res.writeHead(init.status, init.statusText, init.headers).end(body);
+        }
+        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);
+            if (isProd) {
+                res.writeHead(500).end();
+            }
+            else {
+                res
+                    .writeHead(500, { 'content-type': 'application/json; charset=utf-8' })
+                    .end(JSON.stringify({
+                    errors: [
+                        err instanceof Error
+                            ? {
+                                message: err.message,
+                                stack: err.stack,
+                            }
+                            : err,
+                    ],
+                }));
+            }
+        }
+    };
+}
+exports.createHandler = createHandler;

package/lib/use/http.mjs

@@ -0,0 +1,68 @@
+import { createHandler as createRawHandler, } from '../handler.mjs';
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for
+ * the Node environment http module.
+ *
+ * ```js
+ * import http from 'http';
+ * import { createHandler } from 'graphql-http/lib/use/http';
+ * import { schema } from './my-graphql-step/index.mjs';
+ *
+ * const server = http.createServer(createHandler({ schema }));
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/http
+ */
+export function createHandler(options) {
+    const isProd = process.env.NODE_ENV === 'production';
+    const handle = createRawHandler(options);
+    return async function requestListener(req, res) {
+        try {
+            if (!req.url) {
+                throw new Error('Missing request URL');
+            }
+            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 },
+            });
+            res.writeHead(init.status, init.statusText, init.headers).end(body);
+        }
+        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);
+            if (isProd) {
+                res.writeHead(500).end();
+            }
+            else {
+                res
+                    .writeHead(500, { 'content-type': 'application/json; charset=utf-8' })
+                    .end(JSON.stringify({
+                    errors: [
+                        err instanceof Error
+                            ? {
+                                message: err.message,
+                                stack: err.stack,
+                            }
+                            : err,
+                    ],
+                }));
+            }
+        }
+    };
+}

package/lib/use/http2.d.mts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import type { Http2ServerRequest, Http2ServerResponse } from 'http2';
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
+/**
+ * The context in the request for the handler.
+ *
+ * @category Server/http2
+ */
+export interface RequestContext {
+    res: Http2ServerResponse;
+}
+/**
+ * Handler options when using the http adapter.
+ *
+ * @category Server/http2
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<Http2ServerRequest, RequestContext, Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for
+ * the Node environment http2 module.
+ *
+ *  ```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 { createHandler } from 'graphql-http/lib/use/http2';
+ * import { schema } from './my-graphql-step';
+ *
+ * const server = http2.createSecureServer(
+ *   {
+ *     key: fs.readFileSync('localhost-privkey.pem'),
+ *     cert: fs.readFileSync('localhost-cert.pem'),
+ *   },
+ *   createHandler({ schema }),
+ * );
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/http2
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>): (req: Http2ServerRequest, res: Http2ServerResponse) => Promise<void>;

package/lib/use/http2.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import type { Http2ServerRequest, Http2ServerResponse } from 'http2';
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
+/**
+ * The context in the request for the handler.
+ *
+ * @category Server/http2
+ */
+export interface RequestContext {
+    res: Http2ServerResponse;
+}
+/**
+ * Handler options when using the http adapter.
+ *
+ * @category Server/http2
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<Http2ServerRequest, RequestContext, Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for
+ * the Node environment http2 module.
+ *
+ *  ```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 { createHandler } from 'graphql-http/lib/use/http2';
+ * import { schema } from './my-graphql-step';
+ *
+ * const server = http2.createSecureServer(
+ *   {
+ *     key: fs.readFileSync('localhost-privkey.pem'),
+ *     cert: fs.readFileSync('localhost-cert.pem'),
+ *   },
+ *   createHandler({ schema }),
+ * );
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/http2
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>): (req: Http2ServerRequest, res: Http2ServerResponse) => Promise<void>;

package/lib/use/http2.js

@@ -0,0 +1,90 @@
+"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
+ * the Node environment http2 module.
+ *
+ *  ```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 { createHandler } from 'graphql-http/lib/use/http2';
+ * import { schema } from './my-graphql-step';
+ *
+ * const server = http2.createSecureServer(
+ *   {
+ *     key: fs.readFileSync('localhost-privkey.pem'),
+ *     cert: fs.readFileSync('localhost-cert.pem'),
+ *   },
+ *   createHandler({ schema }),
+ * );
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/http2
+ */
+function createHandler(options) {
+    const isProd = process.env.NODE_ENV === 'production';
+    const handle = (0, handler_1.createHandler)(options);
+    return async function requestListener(req, res) {
+        try {
+            if (!req.url) {
+                throw new Error('Missing request URL');
+            }
+            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 },
+            });
+            res.writeHead(init.status, init.statusText, init.headers);
+            if (body) {
+                res.end(body);
+            }
+            else {
+                res.end();
+            }
+        }
+        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);
+            if (isProd) {
+                res.writeHead(500).end();
+            }
+            else {
+                res
+                    .writeHead(500, { 'content-type': 'application/json; charset=utf-8' })
+                    .end(JSON.stringify({
+                    errors: [
+                        err instanceof Error
+                            ? {
+                                message: err.message,
+                                stack: err.stack,
+                            }
+                            : err,
+                    ],
+                }));
+            }
+        }
+    };
+}
+exports.createHandler = createHandler;

package/lib/use/http2.mjs

@@ -0,0 +1,86 @@
+import { createHandler as createRawHandler, } from '../handler.mjs';
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for
+ * the Node environment http2 module.
+ *
+ *  ```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 { createHandler } from 'graphql-http/lib/use/http2';
+ * import { schema } from './my-graphql-step/index.mjs';
+ *
+ * const server = http2.createSecureServer(
+ *   {
+ *     key: fs.readFileSync('localhost-privkey.pem'),
+ *     cert: fs.readFileSync('localhost-cert.pem'),
+ *   },
+ *   createHandler({ schema }),
+ * );
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/http2
+ */
+export function createHandler(options) {
+    const isProd = process.env.NODE_ENV === 'production';
+    const handle = createRawHandler(options);
+    return async function requestListener(req, res) {
+        try {
+            if (!req.url) {
+                throw new Error('Missing request URL');
+            }
+            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 },
+            });
+            res.writeHead(init.status, init.statusText, init.headers);
+            if (body) {
+                res.end(body);
+            }
+            else {
+                res.end();
+            }
+        }
+        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);
+            if (isProd) {
+                res.writeHead(500).end();
+            }
+            else {
+                res
+                    .writeHead(500, { 'content-type': 'application/json; charset=utf-8' })
+                    .end(JSON.stringify({
+                    errors: [
+                        err instanceof Error
+                            ? {
+                                message: err.message,
+                                stack: err.stack,
+                            }
+                            : err,
+                    ],
+                }));
+            }
+        }
+    };
+}

package/lib/use/koa.d.mts

@@ -1,9 +1,23 @@
 /// <reference types="node" />
-import type { Middleware } from 'koa';
+import type { Middleware, Response } from 'koa';
 import type { IncomingMessage } from 'http';
-import { HandlerOptions, OperationContext } from '../handler';
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
 /**
- * Create a GraphQL over HTTP Protocol compliant request handler for
+ * The context in the request for the handler.
+ *
+ * @category Server/koa
+ */
+export interface RequestContext {
+    res: Response;
+}
+/**
+ * Handler options when using the koa adapter.
+ *
+ * @category Server/koa
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<IncomingMessage, RequestContext, Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for
  * the Koa framework.
  *
  * ```js
@@ -21,4 +35,4 @@ import { HandlerOptions, OperationContext } from '../handler';
  *
  * @category Server/koa
  */
-export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<IncomingMessage, undefined, Context>): Middleware;
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>): Middleware;

package/lib/use/koa.d.ts

@@ -1,9 +1,23 @@
 /// <reference types="node" />
-import type { Middleware } from 'koa';
+import type { Middleware, Response } from 'koa';
 import type { IncomingMessage } from 'http';
-import { HandlerOptions, OperationContext } from '../handler';
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
 /**
- * Create a GraphQL over HTTP Protocol compliant request handler for
+ * The context in the request for the handler.
+ *
+ * @category Server/koa
+ */
+export interface RequestContext {
+    res: Response;
+}
+/**
+ * Handler options when using the koa adapter.
+ *
+ * @category Server/koa
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<IncomingMessage, RequestContext, Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for
  * the Koa framework.
  *
  * ```js
@@ -21,4 +35,4 @@ import { HandlerOptions, OperationContext } from '../handler';
  *
  * @category Server/koa
  */
-export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<IncomingMessage, undefined, Context>): Middleware;
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>): Middleware;

package/lib/use/koa.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHandler = void 0;
 const handler_1 = require("../handler");
 /**
- * Create a GraphQL over HTTP Protocol compliant request handler for
+ * Create a GraphQL over HTTP spec compliant request handler for
  * the Koa framework.
  *
  * ```js
@@ -42,7 +42,7 @@ function createHandler(options) {
                     });
                 },
                 raw: ctx.req,
-                context: undefined,
+                context: { res: ctx.response },
             });
             ctx.body = body;
             ctx.response.status = init.status;

package/lib/use/koa.mjs

@@ -1,6 +1,6 @@
 import { createHandler as createRawHandler, } from '../handler.mjs';
 /**
- * Create a GraphQL over HTTP Protocol compliant request handler for
+ * Create a GraphQL over HTTP spec compliant request handler for
  * the Koa framework.
  *
  * ```js
@@ -39,7 +39,7 @@ export function createHandler(options) {
                     });
                 },
                 raw: ctx.req,
-                context: undefined,
+                context: { res: ctx.response },
             });
             ctx.body = body;
             ctx.response.status = init.status;

package/lib/use/node.d.mts

@@ -1,8 +1,16 @@
 /// <reference types="node" />
-import type { IncomingMessage, RequestListener } from 'http';
-import { HandlerOptions, OperationContext } from '../handler';
+import { HandlerOptions as HttpHandlerOptions } from './http';
+import { OperationContext } from '../handler';
 /**
- * Create a GraphQL over HTTP Protocol compliant request handler for
+ * Handler options when using the node adapter.
+ *
+ * @category Server/node
+ *
+ * @deprecated Please use {@link use/http.HandlerOptions | http} or {@link use/http2.HandlerOptions | http2} adapters instead.
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = HttpHandlerOptions<Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for
  * the Node environment.
  *
  * ```js
@@ -17,5 +25,7 @@ import { HandlerOptions, OperationContext } from '../handler';
  * ```
  *
  * @category Server/node
+ *
+ * @deprecated Please use {@link use/http.createHandler | http} or {@link use/http2.createHandler | http2} adapters instead.
  */
-export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<IncomingMessage, undefined, Context>): RequestListener;
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>): (req: import("http").IncomingMessage, res: import("http").ServerResponse<import("http").IncomingMessage>) => Promise<void>;

package/lib/use/node.d.ts

@@ -1,8 +1,16 @@
 /// <reference types="node" />
-import type { IncomingMessage, RequestListener } from 'http';
-import { HandlerOptions, OperationContext } from '../handler';
+import { HandlerOptions as HttpHandlerOptions } from './http';
+import { OperationContext } from '../handler';
 /**
- * Create a GraphQL over HTTP Protocol compliant request handler for
+ * Handler options when using the node adapter.
+ *
+ * @category Server/node
+ *
+ * @deprecated Please use {@link use/http.HandlerOptions | http} or {@link use/http2.HandlerOptions | http2} adapters instead.
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = HttpHandlerOptions<Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for
  * the Node environment.
  *
  * ```js
@@ -17,5 +25,7 @@ import { HandlerOptions, OperationContext } from '../handler';
  * ```
  *
  * @category Server/node
+ *
+ * @deprecated Please use {@link use/http.createHandler | http} or {@link use/http2.createHandler | http2} adapters instead.
  */
-export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<IncomingMessage, undefined, Context>): RequestListener;
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>): (req: import("http").IncomingMessage, res: import("http").ServerResponse<import("http").IncomingMessage>) => Promise<void>;

package/lib/use/node.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHandler = void 0;
-const handler_1 = require("../handler");
+const http_1 = require("./http");
 /**
- * Create a GraphQL over HTTP Protocol compliant request handler for
+ * Create a GraphQL over HTTP spec compliant request handler for
  * the Node environment.
  *
  * ```js
@@ -18,55 +18,10 @@ const handler_1 = require("../handler");
  * ```
  *
  * @category Server/node
+ *
+ * @deprecated Please use {@link use/http.createHandler | http} or {@link use/http2.createHandler | http2} adapters instead.
  */
 function createHandler(options) {
-    const isProd = process.env.NODE_ENV === 'production';
-    const handle = (0, handler_1.createHandler)(options);
-    return async function requestListener(req, res) {
-        try {
-            if (!req.url) {
-                throw new Error('Missing request URL');
-            }
-            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: undefined,
-            });
-            res.writeHead(init.status, init.statusText, init.headers).end(body);
-        }
-        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);
-            if (isProd) {
-                res.writeHead(500).end();
-            }
-            else {
-                res
-                    .writeHead(500, { 'content-type': 'application/json; charset=utf-8' })
-                    .end(JSON.stringify({
-                    errors: [
-                        err instanceof Error
-                            ? {
-                                message: err.message,
-                                stack: err.stack,
-                            }
-                            : err,
-                    ],
-                }));
-            }
-        }
-    };
+    return (0, http_1.createHandler)(options);
 }
 exports.createHandler = createHandler;