graphql-http 1.6.1 → 1.7.0

package/lib/handler.d.ts

@@ -8,27 +8,25 @@ import { RequestParams } from './common';
 /**
  * The incoming request headers the implementing server should provide.
  *
- * @category Common
+ * @category Server
  */
-export interface RequestHeaders {
-    accept?: string | undefined;
-    allow?: string | undefined;
-    'content-type'?: string | undefined;
+export declare type RequestHeaders = {
     /**
      * Always an array in Node. Duplicates are added to it.
-     * Not necessarily true for other environments, make sure
-     * to check the type during runtime.
+     * Not necessarily true for other environments.
      */
     'set-cookie'?: string | string[] | undefined;
     [key: string]: string | string[] | undefined;
-}
+} | {
+    get: (key: string) => string | null;
+};
 /**
  * Server agnostic request interface containing the raw request
  * which is server dependant.
  *
- * @category Common
+ * @category Server
  */
-export interface Request<RawRequest, Context> {
+export interface Request<Raw, Context> {
     readonly method: string;
     readonly url: string;
     readonly headers: RequestHeaders;
@@ -45,7 +43,7 @@ export interface Request<RawRequest, Context> {
      * For example: `express.Request` when using Express, or maybe
      * `http.IncomingMessage` when just using Node with `http.createServer`.
      */
-    readonly raw: RawRequest;
+    readonly raw: Raw;
     /**
      * Context value about the incoming request, you're free to pass any information here.
      */
@@ -54,7 +52,7 @@ export interface Request<RawRequest, Context> {
 /**
  * The response headers that get returned from graphql-http.
  *
- * @category Common
+ * @category Server
  */
 export declare type ResponseHeaders = {
     accept?: string;
@@ -65,14 +63,14 @@ export declare type ResponseHeaders = {
  * Server agnostic response body returned from `graphql-http` needing
  * to be coerced to the server implementation in use.
  *
- * @category Common
+ * @category Server
  */
 export declare type ResponseBody = string;
 /**
  * Server agnostic response options (ex. status and headers) returned from
  * `graphql-http` needing to be coerced to the server implementation in use.
  *
- * @category Common
+ * @category Server
  */
 export interface ResponseInit {
     readonly status: number;
@@ -83,13 +81,13 @@ export interface ResponseInit {
  * Server agnostic response returned from `graphql-http` containing the
  * body and init options needing to be coerced to the server implementation in use.
  *
- * @category Common
+ * @category Server
  */
 export declare type Response = readonly [body: ResponseBody | null, init: ResponseInit];
 /**
  * Checks whether the passed value is the `graphql-http` server agnostic response.
  *
- * @category Common
+ * @category Server
  */
 export declare function isResponse(val: unknown): val is Response;
 /**
@@ -102,9 +100,13 @@ export declare function isResponse(val: unknown): val is Response;
  *
  * @category Server
  */
-export declare type ExecutionContext = object | symbol | number | string | boolean | undefined | null;
+export declare type OperationContext = Record<PropertyKey, unknown> | symbol | number | string | boolean | undefined | null;
+/** @category Server */
+export declare type OperationArgs<Context extends OperationContext = undefined> = ExecutionArgs & {
+    contextValue?: Context;
+};
 /** @category Server */
-export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
+export interface HandlerOptions<RequestRaw = unknown, RequestContext = unknown, Context extends OperationContext = undefined> {
     /**
      * The GraphQL schema on which the operations will
      * be executed and validated against.
@@ -121,13 +123,13 @@ export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
      * you should do by returning a `Request` argument which will stop
      * further execution.
      */
-    schema?: GraphQLSchema | ((req: Request<RawRequest, Context>, args: Omit<ExecutionArgs, 'schema'>) => Promise<GraphQLSchema | Response> | GraphQLSchema | Response);
+    schema?: GraphQLSchema | ((req: Request<RequestRaw, RequestContext>, args: Omit<OperationArgs<Context>, 'schema'>) => Promise<GraphQLSchema | Response> | GraphQLSchema | Response);
     /**
      * A value which is provided to every resolver and holds
      * important contextual information like the currently
      * logged in user, or access to a database.
      */
-    context?: ExecutionContext | ((req: Request<RawRequest, Context>, args: ExecutionArgs) => Promise<ExecutionContext | Response> | ExecutionContext | Response);
+    context?: Context | ((req: Request<RequestRaw, RequestContext>, params: RequestParams) => Promise<Context | Response> | Context | Response);
     /**
      * A custom GraphQL validate function allowing you to apply your
      * own validation rules.
@@ -176,7 +178,7 @@ export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
      * you should do by returning a `Request` argument which will stop
      * further execution.
      */
-    onSubscribe?: (req: Request<RawRequest, Context>, params: RequestParams) => Promise<ExecutionResult | ExecutionArgs | readonly GraphQLError[] | Response | void> | ExecutionResult | ExecutionArgs | readonly GraphQLError[] | Response | void;
+    onSubscribe?: (req: Request<RequestRaw, RequestContext>, params: RequestParams) => Promise<ExecutionResult | OperationArgs<Context> | readonly GraphQLError[] | Response | void> | ExecutionResult | OperationArgs<Context> | readonly GraphQLError[] | Response | void;
     /**
      * Executed after the operation call resolves.
      *
@@ -190,7 +192,7 @@ export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
      * you should do by returning a `Request` argument which will stop
      * further execution.
      */
-    onOperation?: (req: Request<RawRequest, Context>, args: ExecutionArgs, result: ExecutionResult) => Promise<ExecutionResult | Response | void> | ExecutionResult | Response | void;
+    onOperation?: (req: Request<RequestRaw, RequestContext>, args: OperationArgs<Context>, result: ExecutionResult) => Promise<ExecutionResult | Response | void> | ExecutionResult | Response | void;
 }
 /**
  * The ready-to-use handler. Simply plug it in your favourite HTTP framework
@@ -202,7 +204,7 @@ export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
  *
  * @category Server
  */
-export declare type Handler<RawRequest = unknown, Context = unknown> = (req: Request<RawRequest, Context>) => Promise<Response>;
+export declare type Handler<RequestRaw = unknown, RequestContext = unknown> = (req: Request<RequestRaw, RequestContext>) => Promise<Response>;
 /**
  * Makes a GraphQL over HTTP Protocol compliant server handler. The handler can
  * be used with your favourite server library.
@@ -258,7 +260,7 @@ export declare type Handler<RawRequest = unknown, Context = unknown> = (req: Req
  *
  * @category Server
  */
-export declare function createHandler<RawRequest = unknown, Context = unknown>(options: HandlerOptions<RawRequest, Context>): Handler<RawRequest, Context>;
+export declare function createHandler<RequestRaw = unknown, RequestContext = unknown, Context extends OperationContext = undefined>(options: HandlerOptions<RequestRaw, RequestContext, Context>): Handler<RequestRaw, RequestContext>;
 /**
  * Request's Media-Type that the server accepts.
  *

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