graphql-http 1.19.0 → 1.21.0

package/lib/handler.mjs

@@ -4,13 +4,9 @@
  *
  */
 import { validate as graphqlValidate, specifiedRules, execute as graphqlExecute, parse as graphqlParse, getOperationAST as graphqlGetOperationAST, GraphQLError, } from 'graphql';
-import { areGraphQLErrors, isAsyncIterable, isExecutionResult, isGraphQLError, isObject, jsonErrorReplacer, } from './utils.mjs';
-/**
- * Checks whether the passed value is the `graphql-http` server agnostic response.
- *
- * @category Server
- */
-export function isResponse(val) {
+import { isAsyncIterable, isExecutionResult, isObject } from './utils.mjs';
+/** Checks whether the passed value is the `graphql-http` server agnostic response. */
+function isResponse(val) {
     // TODO: make sure the contents of init match ResponseInit
     return (Array.isArray(val) &&
         (typeof val[0] === 'string' || val[0] === null) &&
@@ -18,7 +14,7 @@ export function isResponse(val) {
 }
 /**
  * Makes a GraphQL over HTTP spec compliant server handler. The handler can
- * be used with your favourite server library.
+ * be used with your favorite server library.
  *
  * Beware that the handler resolves only after the whole operation completes.
  *
@@ -72,23 +68,32 @@ export function isResponse(val) {
  * @category Server
  */
 export function createHandler(options) {
-    const { schema, context, validate = graphqlValidate, validationRules = [], execute = graphqlExecute, parse = graphqlParse, getOperationAST = graphqlGetOperationAST, rootValue, onSubscribe, onOperation, formatError = (err) => err, } = options;
+    const { schema, context, validate = graphqlValidate, validationRules = [], execute = graphqlExecute, parse = graphqlParse, getOperationAST = graphqlGetOperationAST, rootValue, onSubscribe, onOperation, formatError = (err) => err, parseRequestParams = defaultParseRequestParams, } = options;
     return async function handler(req) {
-        var _a, _b;
-        const method = req.method;
-        if (method !== 'GET' && method !== 'POST') {
-            return [
-                null,
-                {
-                    status: 405,
-                    statusText: 'Method Not Allowed',
-                    headers: {
-                        allow: 'GET, POST',
-                    },
-                },
-            ];
+        let acceptedMediaType = null;
+        const accepts = (getHeader(req, 'accept') || '*/*')
+            .replace(/\s/g, '')
+            .toLowerCase()
+            .split(',');
+        for (const accept of accepts) {
+            // accept-charset became obsolete, shouldnt be used (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Charset)
+            // TODO: handle the weight parameter "q"
+            const [mediaType, ...params] = accept.split(';');
+            const charset = (params === null || params === void 0 ? void 0 : params.find((param) => param.includes('charset='))) || 'charset=utf8'; // utf-8 is assumed when not specified;
+            if (mediaType === 'application/graphql-response+json' &&
+                charset === 'charset=utf8') {
+                acceptedMediaType = 'application/graphql-response+json';
+                break;
+            }
+            // application/json should be the default until watershed
+            if ((mediaType === 'application/json' ||
+                mediaType === 'application/*' ||
+                mediaType === '*/*') &&
+                charset === 'charset=utf8') {
+                acceptedMediaType = 'application/json';
+                break;
+            }
         }
-        const acceptedMediaType = getAcceptableMediaType(getHeader(req, 'accept'));
         if (!acceptedMediaType) {
             return [
                 null,
@@ -101,89 +106,14 @@ 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)
-        ] = (getHeader(req, 'content-type') || '')
-            .replace(/\s/g, '')
-            .toLowerCase()
-            .split(';');
         let params;
         try {
-            const partParams = {};
-            switch (true) {
-                case method === 'GET': {
-                    // TODO: what if content-type is specified and is not application/x-www-form-urlencoded?
-                    try {
-                        const [, search] = req.url.split('?');
-                        const searchParams = new URLSearchParams(search);
-                        partParams.operationName =
-                            (_a = searchParams.get('operationName')) !== null && _a !== void 0 ? _a : undefined;
-                        partParams.query = (_b = searchParams.get('query')) !== null && _b !== void 0 ? _b : undefined;
-                        const variables = searchParams.get('variables');
-                        if (variables)
-                            partParams.variables = JSON.parse(variables);
-                        const extensions = searchParams.get('extensions');
-                        if (extensions)
-                            partParams.extensions = JSON.parse(extensions);
-                    }
-                    catch (_c) {
-                        throw new Error('Unparsable URL');
-                    }
-                    break;
-                }
-                case method === 'POST' &&
-                    mediaType === 'application/json' &&
-                    charset === 'charset=utf-8':
-                    {
-                        if (!req.body) {
-                            throw new Error('Missing body');
-                        }
-                        let data;
-                        try {
-                            const body = typeof req.body === 'function' ? await req.body() : req.body;
-                            data = typeof body === 'string' ? JSON.parse(body) : body;
-                        }
-                        catch (err) {
-                            throw new Error('Unparsable JSON body');
-                        }
-                        if (!isObject(data)) {
-                            throw new Error('JSON body must be an object');
-                        }
-                        partParams.operationName = data.operationName;
-                        partParams.query = data.query;
-                        partParams.variables = data.variables;
-                        partParams.extensions = data.extensions;
-                        break;
-                    }
-                default: // graphql-http doesnt support any other content type
-                    return [
-                        null,
-                        {
-                            status: 415,
-                            statusText: 'Unsupported Media Type',
-                        },
-                    ];
-            }
-            if (partParams.query == null)
-                throw new Error('Missing query');
-            if (typeof partParams.query !== 'string')
-                throw new Error('Invalid query');
-            if (partParams.variables != null &&
-                (typeof partParams.variables !== 'object' ||
-                    Array.isArray(partParams.variables))) {
-                throw new Error('Invalid variables');
-            }
-            if (partParams.operationName != null &&
-                typeof partParams.operationName !== 'string') {
-                throw new Error('Invalid operationName');
-            }
-            if (partParams.extensions != null &&
-                (typeof partParams.extensions !== 'object' ||
-                    Array.isArray(partParams.extensions))) {
-                throw new Error('Invalid extensions');
-            }
-            // request parameters are checked and now complete
-            params = partParams;
+            let paramsOrRes = await parseRequestParams(req);
+            if (!paramsOrRes)
+                paramsOrRes = await defaultParseRequestParams(req);
+            if (isResponse(paramsOrRes))
+                return paramsOrRes;
+            params = paramsOrRes;
         }
         catch (err) {
             return makeResponse(err, acceptedMediaType, formatError);
@@ -245,7 +175,7 @@ export function createHandler(options) {
                 throw null;
             operation = ast.operation;
         }
-        catch (_d) {
+        catch (_a) {
             return makeResponse(new GraphQLError('Unable to detect operation AST'), acceptedMediaType, formatError);
         }
         if (operation === 'subscription') {
@@ -253,7 +183,7 @@ export function createHandler(options) {
         }
         // mutations cannot happen over GETs
         // https://graphql.github.io/graphql-over-http/draft/#sel-CALFJRPAAELBAAxwP
-        if (operation === 'mutation' && method === 'GET') {
+        if (operation === 'mutation' && req.method === 'GET') {
             return [
                 JSON.stringify({
                     errors: [new GraphQLError('Cannot perform mutations over GET')],
@@ -289,36 +219,108 @@ export function createHandler(options) {
     };
 }
 /**
- * Inspects the request and detects the appropriate/acceptable Media-Type
- * looking at the `Accept` header while complying with the GraphQL over HTTP spec.
+ * The default request params parser. Used when no custom one is provided or if it
+ * returns nothing.
  *
- * @category Server
+ * Read more about it in {@link ParseRequestParams}.
+ *
+ * TODO: should graphql-http itself care about content-encoding? I'd say unzipping should happen before handler is reached
  */
-export function getAcceptableMediaType(acceptHeader) {
-    let acceptedMediaType = null;
-    const accepts = (acceptHeader || '*/*')
+async function defaultParseRequestParams(req) {
+    var _a, _b;
+    const method = req.method;
+    if (method !== 'GET' && method !== 'POST') {
+        return [
+            null,
+            {
+                status: 405,
+                statusText: 'Method Not Allowed',
+                headers: {
+                    allow: 'GET, POST',
+                },
+            },
+        ];
+    }
+    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)
+    ] = (getHeader(req, 'content-type') || '')
         .replace(/\s/g, '')
         .toLowerCase()
-        .split(',');
-    for (const accept of accepts) {
-        // accept-charset became obsolete, shouldnt be used (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Charset)
-        // TODO: handle the weight parameter "q"
-        const [mediaType, ...params] = accept.split(';');
-        const charset = (params === null || params === void 0 ? void 0 : params.find((param) => param.includes('charset='))) || 'charset=utf8'; // utf-8 is assumed when not specified;
-        if (mediaType === 'application/graphql-response+json' &&
-            charset === 'charset=utf8') {
-            acceptedMediaType = 'application/graphql-response+json';
-            break;
-        }
-        if ((mediaType === 'application/json' ||
-            mediaType === 'application/*' ||
-            mediaType === '*/*') &&
-            charset === 'charset=utf8') {
-            acceptedMediaType = 'application/json';
+        .split(';');
+    const partParams = {};
+    switch (true) {
+        case method === 'GET': {
+            // TODO: what if content-type is specified and is not application/x-www-form-urlencoded?
+            try {
+                const [, search] = req.url.split('?');
+                const searchParams = new URLSearchParams(search);
+                partParams.operationName =
+                    (_a = searchParams.get('operationName')) !== null && _a !== void 0 ? _a : undefined;
+                partParams.query = (_b = searchParams.get('query')) !== null && _b !== void 0 ? _b : undefined;
+                const variables = searchParams.get('variables');
+                if (variables)
+                    partParams.variables = JSON.parse(variables);
+                const extensions = searchParams.get('extensions');
+                if (extensions)
+                    partParams.extensions = JSON.parse(extensions);
+            }
+            catch (_c) {
+                throw new Error('Unparsable URL');
+            }
             break;
         }
+        case method === 'POST' &&
+            mediaType === 'application/json' &&
+            charset === 'charset=utf-8':
+            {
+                if (!req.body) {
+                    throw new Error('Missing body');
+                }
+                let data;
+                try {
+                    const body = typeof req.body === 'function' ? await req.body() : req.body;
+                    data = typeof body === 'string' ? JSON.parse(body) : body;
+                }
+                catch (err) {
+                    throw new Error('Unparsable JSON body');
+                }
+                if (!isObject(data)) {
+                    throw new Error('JSON body must be an object');
+                }
+                partParams.operationName = data.operationName;
+                partParams.query = data.query;
+                partParams.variables = data.variables;
+                partParams.extensions = data.extensions;
+                break;
+            }
+        default: // graphql-http doesnt support any other content type
+            return [
+                null,
+                {
+                    status: 415,
+                    statusText: 'Unsupported Media Type',
+                },
+            ];
+    }
+    if (partParams.query == null)
+        throw new Error('Missing query');
+    if (typeof partParams.query !== 'string')
+        throw new Error('Invalid query');
+    if (partParams.variables != null &&
+        (typeof partParams.variables !== 'object' ||
+            Array.isArray(partParams.variables))) {
+        throw new Error('Invalid variables');
+    }
+    if (partParams.operationName != null &&
+        typeof partParams.operationName !== 'string') {
+        throw new Error('Invalid operationName');
     }
-    return acceptedMediaType;
+    if (partParams.extensions != null &&
+        (typeof partParams.extensions !== 'object' ||
+            Array.isArray(partParams.extensions))) {
+        throw new Error('Invalid extensions');
+    }
+    // request parameters are checked and now complete
+    return partParams;
 }
 /**
  * Creates an appropriate GraphQL over HTTP response following the provided arguments.
@@ -330,10 +332,8 @@ export function getAcceptableMediaType(acceptHeader) {
  *
  * If the first argument is an `Error`, the operation will be treated as a bad request responding with `400: Bad Request` and the
  * error will be present in the `ExecutionResult` style.
- *
- * @category Server
  */
-export function makeResponse(resultOrErrors, acceptedMediaType, formatError) {
+function makeResponse(resultOrErrors, acceptedMediaType, formatError) {
     if (resultOrErrors instanceof Error &&
         // because GraphQLError extends the Error class
         !isGraphQLError(resultOrErrors)) {
@@ -391,3 +391,26 @@ function getHeader(req, key) {
     }
     return Object(req.headers)[key];
 }
+function areGraphQLErrors(obj) {
+    return (Array.isArray(obj) &&
+        obj.length > 0 &&
+        // if one item in the array is a GraphQLError, we're good
+        obj.some(isGraphQLError));
+}
+function isGraphQLError(obj) {
+    return obj instanceof GraphQLError;
+}
+function jsonErrorReplacer(_key, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+val) {
+    if (val instanceof Error &&
+        // GraphQL errors implement their own stringer
+        !isGraphQLError(val)) {
+        return {
+            // name: val.name, name is included in message
+            message: val.message,
+            // stack: val.stack, can leak sensitive details
+        };
+    }
+    return val;
+}

package/lib/use/@netlify/functions.d.mts

@@ -0,0 +1,14 @@
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../../handler.mjs';
+import type { Handler as NetlifyHandler, HandlerEvent as NetlifyHandlerEvent, HandlerContext as NetlifyHandlerContext } from '@netlify/functions';
+/**
+ * Handler options when using the netlify adapter
+ *
+ * @category Server/@netlify/functions
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<NetlifyHandlerEvent, NetlifyHandlerContext, Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for netlify functions
+ *
+ * @category Server/@netlify/functions
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>): NetlifyHandler;

package/lib/use/@netlify/functions.d.ts

@@ -0,0 +1,14 @@
+import { HandlerOptions as RawHandlerOptions, OperationContext } from '../../handler';
+import type { Handler as NetlifyHandler, HandlerEvent as NetlifyHandlerEvent, HandlerContext as NetlifyHandlerContext } from '@netlify/functions';
+/**
+ * Handler options when using the netlify adapter
+ *
+ * @category Server/@netlify/functions
+ */
+export type HandlerOptions<Context extends OperationContext = undefined> = RawHandlerOptions<NetlifyHandlerEvent, NetlifyHandlerContext, Context>;
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for netlify functions
+ *
+ * @category Server/@netlify/functions
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<Context>): NetlifyHandler;

package/lib/use/@netlify/functions.js

@@ -0,0 +1,37 @@
+"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 netlify functions
+ *
+ * @category Server/@netlify/functions
+ */
+function createHandler(options) {
+    const handler = (0, handler_1.createHandler)(options);
+    return async function handleRequest(req, ctx) {
+        try {
+            const [body, init] = await handler({
+                method: req.httpMethod,
+                url: req.rawUrl,
+                headers: req.headers,
+                body: req.body,
+                raw: req,
+                context: ctx,
+            });
+            return {
+                // if body is null, return undefined
+                body: body !== null && body !== void 0 ? body : undefined,
+                statusCode: init.status,
+            };
+        }
+        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);
+            return { statusCode: 500 };
+        }
+    };
+}
+exports.createHandler = createHandler;

package/lib/use/@netlify/functions.mjs

@@ -0,0 +1,33 @@
+import { createHandler as createRawHandler, } from '../../handler.mjs';
+/**
+ * Create a GraphQL over HTTP spec compliant request handler for netlify functions
+ *
+ * @category Server/@netlify/functions
+ */
+export function createHandler(options) {
+    const handler = createRawHandler(options);
+    return async function handleRequest(req, ctx) {
+        try {
+            const [body, init] = await handler({
+                method: req.httpMethod,
+                url: req.rawUrl,
+                headers: req.headers,
+                body: req.body,
+                raw: req,
+                context: ctx,
+            });
+            return {
+                // if body is null, return undefined
+                body: body !== null && body !== void 0 ? body : undefined,
+                statusCode: init.status,
+            };
+        }
+        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);
+            return { statusCode: 500 };
+        }
+    };
+}

package/lib/utils.d.mts

@@ -4,18 +4,11 @@
  *
  */
 import type { ExecutionResult } from 'graphql';
-import { GraphQLError } from 'graphql';
 /** @private */
 export declare function extendedTypeof(val: unknown): 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | 'array' | 'null';
 /** @private */
 export declare function isObject(val: unknown): val is Record<PropertyKey, any>;
 /** @private */
-export declare function areGraphQLErrors(obj: unknown): obj is readonly GraphQLError[];
-/** @private */
-export declare function isGraphQLError(obj: unknown): obj is GraphQLError;
-/** @private */
 export declare function isExecutionResult(val: unknown): val is ExecutionResult;
 /** @private */
 export declare function isAsyncIterable<T = unknown>(val: unknown): val is AsyncIterable<T>;
-/** @private */
-export declare function jsonErrorReplacer(_key: string, val: any): any;

package/lib/utils.d.ts

@@ -4,18 +4,11 @@
  *
  */
 import type { ExecutionResult } from 'graphql';
-import { GraphQLError } from 'graphql';
 /** @private */
 export declare function extendedTypeof(val: unknown): 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | 'array' | 'null';
 /** @private */
 export declare function isObject(val: unknown): val is Record<PropertyKey, any>;
 /** @private */
-export declare function areGraphQLErrors(obj: unknown): obj is readonly GraphQLError[];
-/** @private */
-export declare function isGraphQLError(obj: unknown): obj is GraphQLError;
-/** @private */
 export declare function isExecutionResult(val: unknown): val is ExecutionResult;
 /** @private */
 export declare function isAsyncIterable<T = unknown>(val: unknown): val is AsyncIterable<T>;
-/** @private */
-export declare function jsonErrorReplacer(_key: string, val: any): any;

package/lib/utils.js

@@ -5,8 +5,7 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsonErrorReplacer = exports.isAsyncIterable = exports.isExecutionResult = exports.isGraphQLError = exports.areGraphQLErrors = exports.isObject = exports.extendedTypeof = void 0;
-const graphql_1 = require("graphql");
+exports.isAsyncIterable = exports.isExecutionResult = exports.isObject = exports.extendedTypeof = void 0;
 /** @private */
 function extendedTypeof(val) {
     if (val === null) {
@@ -24,19 +23,6 @@ function isObject(val) {
 }
 exports.isObject = isObject;
 /** @private */
-function areGraphQLErrors(obj) {
-    return (Array.isArray(obj) &&
-        obj.length > 0 &&
-        // if one item in the array is a GraphQLError, we're good
-        obj.some(isGraphQLError));
-}
-exports.areGraphQLErrors = areGraphQLErrors;
-/** @private */
-function isGraphQLError(obj) {
-    return obj instanceof graphql_1.GraphQLError;
-}
-exports.isGraphQLError = isGraphQLError;
-/** @private */
 function isExecutionResult(val) {
     return (isObject(val) &&
         ('data' in val || ('data' in val && val.data == null && 'errors' in val)));
@@ -47,17 +33,3 @@ function isAsyncIterable(val) {
     return typeof Object(val)[Symbol.asyncIterator] === 'function';
 }
 exports.isAsyncIterable = isAsyncIterable;
-/** @private */
-function jsonErrorReplacer(_key, val) {
-    if (val instanceof Error &&
-        // GraphQL errors implement their own stringer
-        !isGraphQLError(val)) {
-        return {
-            // name: val.name, name is included in message
-            message: val.message,
-            // stack: val.stack, can leak sensitive details
-        };
-    }
-    return val;
-}
-exports.jsonErrorReplacer = jsonErrorReplacer;

package/lib/utils.mjs

@@ -3,7 +3,6 @@
  * utils
  *
  */
-import { GraphQLError } from 'graphql';
 /** @private */
 export function extendedTypeof(val) {
     if (val === null) {
@@ -19,17 +18,6 @@ export function isObject(val) {
     return typeof val === 'object' && val !== null;
 }
 /** @private */
-export function areGraphQLErrors(obj) {
-    return (Array.isArray(obj) &&
-        obj.length > 0 &&
-        // if one item in the array is a GraphQLError, we're good
-        obj.some(isGraphQLError));
-}
-/** @private */
-export function isGraphQLError(obj) {
-    return obj instanceof GraphQLError;
-}
-/** @private */
 export function isExecutionResult(val) {
     return (isObject(val) &&
         ('data' in val || ('data' in val && val.data == null && 'errors' in val)));
@@ -38,16 +26,3 @@ export function isExecutionResult(val) {
 export function isAsyncIterable(val) {
     return typeof Object(val)[Symbol.asyncIterator] === 'function';
 }
-/** @private */
-export function jsonErrorReplacer(_key, val) {
-    if (val instanceof Error &&
-        // GraphQL errors implement their own stringer
-        !isGraphQLError(val)) {
-        return {
-            // name: val.name, name is included in message
-            message: val.message,
-            // stack: val.stack, can leak sensitive details
-        };
-    }
-    return val;
-}