graphql-http 1.6.0 → 1.7.0

package/lib/handler.js

@@ -11,7 +11,7 @@ const utils_1 = require("./utils");
 /**
  * Checks whether the passed value is the `graphql-http` server agnostic response.
  *
- * @category Common
+ * @category Server
  */
 function isResponse(val) {
     // TODO: make sure the contents of init match ResponseInit
@@ -92,7 +92,7 @@ function createHandler(options) {
                 },
             ];
         }
-        const acceptedMediaType = getAcceptableMediaType(req.headers.accept);
+        const acceptedMediaType = getAcceptableMediaType(getHeader(req, 'accept'));
         if (!acceptedMediaType) {
             return [
                 null,
@@ -107,7 +107,7 @@ function createHandler(options) {
         }
         // TODO: should graphql-http care about content-encoding? I'd say unzipping should happen before handler is reached
         const [mediaType, charset = 'charset=utf-8', // utf-8 is assumed when not specified. this parameter is either "charset" or "boundary" (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Length)
-        ] = (req.headers['content-type'] || '')
+        ] = (getHeader(req, 'content-type') || '')
             .replace(/\s/g, '')
             .toLowerCase()
             .split(';');
@@ -208,10 +208,14 @@ function createHandler(options) {
             catch (err) {
                 return makeResponse(err, acceptedMediaType);
             }
+            const resOrContext = typeof context === 'function' ? await context(req, params) : context;
+            if (isResponse(resOrContext))
+                return resOrContext;
             const argsWithoutSchema = {
                 operationName,
                 document,
                 variableValues: variables,
+                contextValue: resOrContext,
             };
             if (typeof schema === 'function') {
                 const resOrSchema = await schema(req, argsWithoutSchema);
@@ -257,10 +261,10 @@ function createHandler(options) {
             ];
         }
         if (!('contextValue' in args)) {
-            const maybeResOrContext = typeof context === 'function' ? await context(req, args) : context;
-            if (isResponse(maybeResOrContext))
-                return maybeResOrContext;
-            args.contextValue = maybeResOrContext;
+            const resOrContext = typeof context === 'function' ? await context(req, params) : context;
+            if (isResponse(resOrContext))
+                return resOrContext;
+            args.contextValue = resOrContext;
         }
         let result = await execute(args);
         const maybeResponseOrResult = await (onOperation === null || onOperation === void 0 ? void 0 : onOperation(req, args, result));
@@ -356,3 +360,9 @@ function makeResponse(resultOrErrors, acceptedMediaType) {
     ];
 }
 exports.makeResponse = makeResponse;
+function getHeader(req, key) {
+    if (typeof req.headers.get === 'function') {
+        return req.headers.get(key);
+    }
+    return Object(req.headers)[key];
+}

package/lib/handler.mjs

@@ -8,7 +8,7 @@ import { areGraphQLErrors, isAsyncIterable, isExecutionResult, isObject, } from
 /**
  * Checks whether the passed value is the `graphql-http` server agnostic response.
  *
- * @category Common
+ * @category Server
  */
 export function isResponse(val) {
     // TODO: make sure the contents of init match ResponseInit
@@ -35,7 +35,7 @@ export function isResponse(val) {
  * ```js
  * import http from 'http';
  * import { createHandler } from 'graphql-http';
- * import { schema } from './my-graphql-schema.mjs';
+ * import { schema } from './my-graphql-schema/index.mjs';
  *
  * // Create the GraphQL over HTTP handler
  * const handler = createHandler({ schema });
@@ -88,7 +88,7 @@ export function createHandler(options) {
                 },
             ];
         }
-        const acceptedMediaType = getAcceptableMediaType(req.headers.accept);
+        const acceptedMediaType = getAcceptableMediaType(getHeader(req, 'accept'));
         if (!acceptedMediaType) {
             return [
                 null,
@@ -103,7 +103,7 @@ export function createHandler(options) {
         }
         // TODO: should graphql-http care about content-encoding? I'd say unzipping should happen before handler is reached
         const [mediaType, charset = 'charset=utf-8', // utf-8 is assumed when not specified. this parameter is either "charset" or "boundary" (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Length)
-        ] = (req.headers['content-type'] || '')
+        ] = (getHeader(req, 'content-type') || '')
             .replace(/\s/g, '')
             .toLowerCase()
             .split(';');
@@ -204,10 +204,14 @@ export function createHandler(options) {
             catch (err) {
                 return makeResponse(err, acceptedMediaType);
             }
+            const resOrContext = typeof context === 'function' ? await context(req, params) : context;
+            if (isResponse(resOrContext))
+                return resOrContext;
             const argsWithoutSchema = {
                 operationName,
                 document,
                 variableValues: variables,
+                contextValue: resOrContext,
             };
             if (typeof schema === 'function') {
                 const resOrSchema = await schema(req, argsWithoutSchema);
@@ -253,10 +257,10 @@ export function createHandler(options) {
             ];
         }
         if (!('contextValue' in args)) {
-            const maybeResOrContext = typeof context === 'function' ? await context(req, args) : context;
-            if (isResponse(maybeResOrContext))
-                return maybeResOrContext;
-            args.contextValue = maybeResOrContext;
+            const resOrContext = typeof context === 'function' ? await context(req, params) : context;
+            if (isResponse(resOrContext))
+                return resOrContext;
+            args.contextValue = resOrContext;
         }
         let result = await execute(args);
         const maybeResponseOrResult = await (onOperation === null || onOperation === void 0 ? void 0 : onOperation(req, args, result));
@@ -349,3 +353,9 @@ export function makeResponse(resultOrErrors, acceptedMediaType) {
             } }),
     ];
 }
+function getHeader(req, key) {
+    if (typeof req.headers.get === 'function') {
+        return req.headers.get(key);
+    }
+    return Object(req.headers)[key];
+}

package/lib/index.d.mts

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './handler';
+export * from './client';
+export * from './audits';

package/lib/index.mjs

@@ -1,4 +1,4 @@
 export * from './common.mjs';
 export * from './handler.mjs';
 export * from './client.mjs';
-export * from './audits.mjs';
+export * from './audits/index.mjs';

package/lib/use/express.d.mts

@@ -0,0 +1,21 @@
+import type { Request, Handler } from 'express';
+import { HandlerOptions, OperationContext } from '../handler';
+/**
+ * Create a GraphQL over HTTP Protocol compliant request handler for
+ * the express framework.
+ *
+ * ```js
+ * import express from 'express'; // yarn add express
+ * import { createHandler } from 'graphql-http/lib/use/express';
+ * import { schema } from './my-graphql-schema';
+ *
+ * const app = express();
+ * app.all('/graphql', createHandler({ schema }));
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/express
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Request, undefined, Context>): Handler;

package/lib/use/express.d.ts

@@ -0,0 +1,21 @@
+import type { Request, Handler } from 'express';
+import { HandlerOptions, OperationContext } from '../handler';
+/**
+ * Create a GraphQL over HTTP Protocol compliant request handler for
+ * the express framework.
+ *
+ * ```js
+ * import express from 'express'; // yarn add express
+ * import { createHandler } from 'graphql-http/lib/use/express';
+ * import { schema } from './my-graphql-schema';
+ *
+ * const app = express();
+ * app.all('/graphql', createHandler({ schema }));
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/express
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Request, undefined, Context>): Handler;

package/lib/use/express.js

@@ -0,0 +1,73 @@
+"use strict";
+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
+ * the express framework.
+ *
+ * ```js
+ * import express from 'express'; // yarn add express
+ * import { createHandler } from 'graphql-http/lib/use/express';
+ * import { schema } from './my-graphql-schema';
+ *
+ * const app = express();
+ * app.all('/graphql', createHandler({ schema }));
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/express
+ */
+function createHandler(options) {
+    const isProd = process.env.NODE_ENV === 'production';
+    const handle = (0, handler_1.createHandler)(options);
+    return async function requestListener(req, res) {
+        try {
+            const [body, init] = await handle({
+                url: req.url,
+                method: req.method,
+                headers: req.headers,
+                body: () => {
+                    if (req.body) {
+                        // in case express has a body parser
+                        return req.body;
+                    }
+                    return new Promise((resolve) => {
+                        let body = '';
+                        req.on('data', (chunk) => (body += chunk));
+                        req.on('end', () => resolve(body));
+                    });
+                },
+                raw: req,
+                context: 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/express.mjs

@@ -0,0 +1,69 @@
+import { createHandler as createRawHandler, } from '../handler.mjs';
+/**
+ * Create a GraphQL over HTTP Protocol compliant request handler for
+ * the express framework.
+ *
+ * ```js
+ * import express from 'express'; // yarn add express
+ * import { createHandler } from 'graphql-http/lib/use/express';
+ * import { schema } from './my-graphql-schema/index.mjs';
+ *
+ * const app = express();
+ * app.all('/graphql', createHandler({ schema }));
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/express
+ */
+export function createHandler(options) {
+    const isProd = process.env.NODE_ENV === 'production';
+    const handle = createRawHandler(options);
+    return async function requestListener(req, res) {
+        try {
+            const [body, init] = await handle({
+                url: req.url,
+                method: req.method,
+                headers: req.headers,
+                body: () => {
+                    if (req.body) {
+                        // in case express has a body parser
+                        return req.body;
+                    }
+                    return new Promise((resolve) => {
+                        let body = '';
+                        req.on('data', (chunk) => (body += chunk));
+                        req.on('end', () => resolve(body));
+                    });
+                },
+                raw: req,
+                context: 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/fastify.d.mts

@@ -0,0 +1,21 @@
+import type { FastifyRequest, RouteHandler } from 'fastify';
+import { HandlerOptions, OperationContext } from '../handler';
+/**
+ * Create a GraphQL over HTTP Protocol compliant request handler for
+ * the fastify framework.
+ *
+ * ```js
+ * import Fastify from 'fastify'; // yarn add fastify
+ * import { createHandler } from 'graphql-http/lib/use/express';
+ * import { schema } from './my-graphql-schema';
+ *
+ * const fastify = Fastify();
+ * fastify.all('/graphql', createHandler({ schema }));
+ *
+ * fastify.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/fastify
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<FastifyRequest, undefined, Context>): RouteHandler;

package/lib/use/fastify.d.ts

@@ -0,0 +1,21 @@
+import type { FastifyRequest, RouteHandler } from 'fastify';
+import { HandlerOptions, OperationContext } from '../handler';
+/**
+ * Create a GraphQL over HTTP Protocol compliant request handler for
+ * the fastify framework.
+ *
+ * ```js
+ * import Fastify from 'fastify'; // yarn add fastify
+ * import { createHandler } from 'graphql-http/lib/use/express';
+ * import { schema } from './my-graphql-schema';
+ *
+ * const fastify = Fastify();
+ * fastify.all('/graphql', createHandler({ schema }));
+ *
+ * fastify.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/fastify
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<FastifyRequest, undefined, Context>): RouteHandler;

package/lib/use/fastify.js

@@ -0,0 +1,69 @@
+"use strict";
+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
+ * the fastify framework.
+ *
+ * ```js
+ * import Fastify from 'fastify'; // yarn add fastify
+ * import { createHandler } from 'graphql-http/lib/use/express';
+ * import { schema } from './my-graphql-schema';
+ *
+ * const fastify = Fastify();
+ * fastify.all('/graphql', createHandler({ schema }));
+ *
+ * fastify.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/fastify
+ */
+function createHandler(options) {
+    const isProd = process.env.NODE_ENV === 'production';
+    const handle = (0, handler_1.createHandler)(options);
+    return async function requestListener(req, reply) {
+        try {
+            const [body, init] = await handle({
+                url: req.url,
+                method: req.method,
+                headers: req.headers,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                body: req.body,
+                raw: req,
+                context: undefined,
+            });
+            reply
+                .status(init.status)
+                .headers(init.headers || {})
+                // "or undefined" because `null` will be JSON stringified
+                .send(body || undefined);
+        }
+        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) {
+                reply.status(500).send();
+            }
+            else {
+                reply
+                    .status(500)
+                    .header('content-type', 'application/json; charset=utf-8')
+                    .send({
+                    errors: [
+                        err instanceof Error
+                            ? {
+                                message: err.message,
+                                stack: err.stack,
+                            }
+                            : err,
+                    ],
+                });
+            }
+        }
+    };
+}
+exports.createHandler = createHandler;

package/lib/use/fastify.mjs

@@ -0,0 +1,65 @@
+import { createHandler as createRawHandler, } from '../handler.mjs';
+/**
+ * Create a GraphQL over HTTP Protocol compliant request handler for
+ * the fastify framework.
+ *
+ * ```js
+ * import Fastify from 'fastify'; // yarn add fastify
+ * import { createHandler } from 'graphql-http/lib/use/express';
+ * import { schema } from './my-graphql-schema/index.mjs';
+ *
+ * const fastify = Fastify();
+ * fastify.all('/graphql', createHandler({ schema }));
+ *
+ * fastify.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/fastify
+ */
+export function createHandler(options) {
+    const isProd = process.env.NODE_ENV === 'production';
+    const handle = createRawHandler(options);
+    return async function requestListener(req, reply) {
+        try {
+            const [body, init] = await handle({
+                url: req.url,
+                method: req.method,
+                headers: req.headers,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                body: req.body,
+                raw: req,
+                context: undefined,
+            });
+            reply
+                .status(init.status)
+                .headers(init.headers || {})
+                // "or undefined" because `null` will be JSON stringified
+                .send(body || undefined);
+        }
+        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) {
+                reply.status(500).send();
+            }
+            else {
+                reply
+                    .status(500)
+                    .header('content-type', 'application/json; charset=utf-8')
+                    .send({
+                    errors: [
+                        err instanceof Error
+                            ? {
+                                message: err.message,
+                                stack: err.stack,
+                            }
+                            : err,
+                    ],
+                });
+            }
+        }
+    };
+}

package/lib/use/fetch.d.mts

@@ -0,0 +1,40 @@
+import { HandlerOptions, OperationContext } from '../handler';
+/**
+ * The necessary API from the fetch environment for the handler.
+ *
+ * @category Server/fetch
+ */
+export interface FetchAPI {
+    Response: typeof Response;
+    ReadableStream: typeof ReadableStream;
+    TextEncoder: typeof TextEncoder;
+}
+/**
+ * Create a GraphQL over HTTP Protocol 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
+ * isomorphically use it in _any_ environment. See an example:
+ *
+ * ```js
+ * import http from 'http';
+ * import { createServerAdapter } from '@whatwg-node/server'; // yarn add @whatwg-node/server
+ * import { createHandler } from 'graphql-http/lib/use/fetch';
+ * import { schema } from './my-graphql-step';
+ *
+ * // Use this adapter in _any_ environment.
+ * const adapter = createServerAdapter({
+ *   handleRequest: createHandler({ schema }),
+ * });
+ *
+ * const server = http.createServer(adapter);
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @param fetchApi - 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>;

package/lib/use/fetch.d.ts

@@ -0,0 +1,40 @@
+import { HandlerOptions, OperationContext } from '../handler';
+/**
+ * The necessary API from the fetch environment for the handler.
+ *
+ * @category Server/fetch
+ */
+export interface FetchAPI {
+    Response: typeof Response;
+    ReadableStream: typeof ReadableStream;
+    TextEncoder: typeof TextEncoder;
+}
+/**
+ * Create a GraphQL over HTTP Protocol 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
+ * isomorphically use it in _any_ environment. See an example:
+ *
+ * ```js
+ * import http from 'http';
+ * import { createServerAdapter } from '@whatwg-node/server'; // yarn add @whatwg-node/server
+ * import { createHandler } from 'graphql-http/lib/use/fetch';
+ * import { schema } from './my-graphql-step';
+ *
+ * // Use this adapter in _any_ environment.
+ * const adapter = createServerAdapter({
+ *   handleRequest: createHandler({ schema }),
+ * });
+ *
+ * const server = http.createServer(adapter);
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @param fetchApi - 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>;