graphql-http 1.14.0 → 1.16.0

package/lib/use/fetch.d.mts

@@ -1,4 +1,4 @@
-import { HandlerOptions, OperationContext } from '../handler';
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
 /**
  * The necessary API from the fetch environment for the handler.
  *
@@ -10,7 +10,13 @@ export interface FetchAPI {
     TextEncoder: typeof TextEncoder;
 }
 /**
- * Create a GraphQL over HTTP Protocol compliant request handler for
+ * Handler options when using the fetch adapter.
+ *
+ * @category Server/fetch
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<Request, FetchAPI, Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for
  * a fetch environment like Deno, Bun, CloudFlare Workers, Lambdas, etc.
  *
  * You can use [@whatwg-node/server](https://github.com/ardatan/whatwg-node/tree/master/packages/server) to create a server adapter and
@@ -33,8 +39,8 @@ export interface FetchAPI {
  * console.log('Listening to port 4000');
  * ```
  *
- * @param fetchApi - Custom fetch API engine, will use from global scope if left undefined.
+ * @param reqCtx - Custom fetch API engine, will use from global scope if left undefined.
  *
  * @category Server/fetch
  */
-export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Request, FetchAPI, Context>, fetchApi?: Partial<FetchAPI>): (req: Request) => Promise<Response>;
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>, reqCtx?: Partial<FetchAPI>): (req: Request) => Promise<Response>;

package/lib/use/fetch.d.ts

@@ -1,4 +1,4 @@
-import { HandlerOptions, OperationContext } from '../handler';
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
 /**
  * The necessary API from the fetch environment for the handler.
  *
@@ -10,7 +10,13 @@ export interface FetchAPI {
     TextEncoder: typeof TextEncoder;
 }
 /**
- * Create a GraphQL over HTTP Protocol compliant request handler for
+ * Handler options when using the fetch adapter.
+ *
+ * @category Server/fetch
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<Request, FetchAPI, Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for
  * a fetch environment like Deno, Bun, CloudFlare Workers, Lambdas, etc.
  *
  * You can use [@whatwg-node/server](https://github.com/ardatan/whatwg-node/tree/master/packages/server) to create a server adapter and
@@ -33,8 +39,8 @@ export interface FetchAPI {
  * console.log('Listening to port 4000');
  * ```
  *
- * @param fetchApi - Custom fetch API engine, will use from global scope if left undefined.
+ * @param reqCtx - Custom fetch API engine, will use from global scope if left undefined.
  *
  * @category Server/fetch
  */
-export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Request, FetchAPI, Context>, fetchApi?: Partial<FetchAPI>): (req: Request) => Promise<Response>;
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>, reqCtx?: Partial<FetchAPI>): (req: Request) => Promise<Response>;

package/lib/use/fetch.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
  * a fetch environment like Deno, Bun, CloudFlare Workers, Lambdas, etc.
  *
  * You can use [@whatwg-node/server](https://github.com/ardatan/whatwg-node/tree/master/packages/server) to create a server adapter and
@@ -26,16 +26,16 @@ const handler_1 = require("../handler");
  * console.log('Listening to port 4000');
  * ```
  *
- * @param fetchApi - Custom fetch API engine, will use from global scope if left undefined.
+ * @param reqCtx - Custom fetch API engine, will use from global scope if left undefined.
  *
  * @category Server/fetch
  */
-function createHandler(options, fetchApi = {}) {
+function createHandler(options, reqCtx = {}) {
     const isProd = process.env.NODE_ENV === 'production';
     const api = {
-        Response: fetchApi.Response || Response,
-        TextEncoder: fetchApi.TextEncoder || TextEncoder,
-        ReadableStream: fetchApi.ReadableStream || ReadableStream,
+        Response: reqCtx.Response || Response,
+        TextEncoder: reqCtx.TextEncoder || TextEncoder,
+        ReadableStream: reqCtx.ReadableStream || ReadableStream,
     };
     const handler = (0, handler_1.createHandler)(options);
     return async function handleRequest(req) {

package/lib/use/fetch.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
  * a fetch environment like Deno, Bun, CloudFlare Workers, Lambdas, etc.
  *
  * You can use [@whatwg-node/server](https://github.com/ardatan/whatwg-node/tree/master/packages/server) to create a server adapter and
@@ -23,16 +23,16 @@ import { createHandler as createRawHandler, } from '../handler.mjs';
  * console.log('Listening to port 4000');
  * ```
  *
- * @param fetchApi - Custom fetch API engine, will use from global scope if left undefined.
+ * @param reqCtx - Custom fetch API engine, will use from global scope if left undefined.
  *
  * @category Server/fetch
  */
-export function createHandler(options, fetchApi = {}) {
+export function createHandler(options, reqCtx = {}) {
     const isProd = process.env.NODE_ENV === 'production';
     const api = {
-        Response: fetchApi.Response || Response,
-        TextEncoder: fetchApi.TextEncoder || TextEncoder,
-        ReadableStream: fetchApi.ReadableStream || ReadableStream,
+        Response: reqCtx.Response || Response,
+        TextEncoder: reqCtx.TextEncoder || TextEncoder,
+        ReadableStream: reqCtx.ReadableStream || ReadableStream,
     };
     const handler = createRawHandler(options);
     return async function handleRequest(req) {

package/lib/use/http.d.mts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import type { IncomingMessage, ServerResponse } from 'http';
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
+/**
+ * Handler options when using the http adapter.
+ *
+ * @category Server/http
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<IncomingMessage, undefined, Context>;
+/**
+ * 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
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>): (req: IncomingMessage, res: ServerResponse) => Promise<void>;

package/lib/use/http.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import type { IncomingMessage, ServerResponse } from 'http';
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
+/**
+ * Handler options when using the http adapter.
+ *
+ * @category Server/http
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<IncomingMessage, undefined, Context>;
+/**
+ * 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
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>): (req: IncomingMessage, res: ServerResponse) => Promise<void>;

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: 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,
+                    ],
+                }));
+            }
+        }
+    };
+}
+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: 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,
+                    ],
+                }));
+            }
+        }
+    };
+}

package/lib/use/http2.d.mts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+import type { Http2ServerRequest, Http2ServerResponse } from 'http2';
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
+/**
+ * Handler options when using the http adapter.
+ *
+ * @category Server/http2
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<Http2ServerRequest, undefined, 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,39 @@
+/// <reference types="node" />
+import type { Http2ServerRequest, Http2ServerResponse } from 'http2';
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
+/**
+ * Handler options when using the http adapter.
+ *
+ * @category Server/http2
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<Http2ServerRequest, undefined, 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: undefined,
+            });
+            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: undefined,
+            });
+            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,15 @@
 /// <reference types="node" />
 import type { Middleware } 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
+ * Handler options when using the koa adapter.
+ *
+ * @category Server/koa
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<IncomingMessage, undefined, Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for
  * the Koa framework.
  *
  * ```js
@@ -21,4 +27,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,15 @@
 /// <reference types="node" />
 import type { Middleware } 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
+ * Handler options when using the koa adapter.
+ *
+ * @category Server/koa
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<IncomingMessage, undefined, Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for
  * the Koa framework.
  *
  * ```js
@@ -21,4 +27,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

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