graphql-http 1.1.0 → 1.4.0

package/README.md

@@ -190,11 +190,7 @@ fastify.all('/graphql', async (req, res) => {
       url: req.url,
       method: req.method,
       headers: req.headers,
-      body: await new Promise((resolve) => {
-        let body = '';
-        req.on('data', (chunk) => (body += chunk));
-        req.on('end', () => resolve(body));
-      }),
+      body: req.body, // fastify reads the body for you
       raw: req,
     });
     res.writeHead(init.status, init.statusText, init.headers).end(body);
@@ -214,8 +210,10 @@ import { serve } from 'https://deno.land/std@0.151.0/http/server.ts';
 import { createHandler } from 'https://esm.sh/graphql-http';
 import { schema } from './previous-step';
 
+// Create the GraphQL over HTTP handler
 const handler = createHandler<Request>({ schema });
 
+// Start serving on `/graphql` using the handler
 await serve(
   async (req: Request) => {
     const [path, _search] = req.url.split('?');

package/lib/client.js

@@ -105,7 +105,7 @@ function createClient(options) {
                             res = await fetchFn(url, {
                                 signal: control.signal,
                                 method: 'POST',
-                                headers: Object.assign(Object.assign({}, headers), { 'content-type': 'application/json; charset=utf-8', accept: 'application/graphql+json, application/json' }),
+                                headers: Object.assign(Object.assign({}, headers), { 'content-type': 'application/json; charset=utf-8', accept: 'application/graphql-response+json, application/json' }),
                                 credentials,
                                 referrer,
                                 referrerPolicy,
@@ -122,7 +122,7 @@ function createClient(options) {
                         const contentType = res.headers.get('content-type');
                         if (!contentType)
                             throw new Error('Missing response content-type');
-                        if (!contentType.includes('application/graphql+json') &&
+                        if (!contentType.includes('application/graphql-response+json') &&
                             !contentType.includes('application/json')) {
                             throw new Error(`Unsupported response content-type ${contentType}`);
                         }

package/lib/client.mjs

@@ -88,7 +88,7 @@ export function createClient(options) {
                             res = await fetchFn(url, {
                                 signal: control.signal,
                                 method: 'POST',
-                                headers: Object.assign(Object.assign({}, headers), { 'content-type': 'application/json; charset=utf-8', accept: 'application/graphql+json, application/json' }),
+                                headers: Object.assign(Object.assign({}, headers), { 'content-type': 'application/json; charset=utf-8', accept: 'application/graphql-response+json, application/json' }),
                                 credentials,
                                 referrer,
                                 referrerPolicy,
@@ -105,7 +105,7 @@ export function createClient(options) {
                         const contentType = res.headers.get('content-type');
                         if (!contentType)
                             throw new Error('Missing response content-type');
-                        if (!contentType.includes('application/graphql+json') &&
+                        if (!contentType.includes('application/graphql-response+json') &&
                             !contentType.includes('application/json')) {
                             throw new Error(`Unsupported response content-type ${contentType}`);
                         }

package/lib/common.d.ts

@@ -3,42 +3,6 @@
  * common
  *
  */
-/**
- * The incoming request headers the implementing server should provide.
- *
- * @category Common
- */
-export interface RequestHeaders {
-    accept?: string | undefined;
-    allow?: string | undefined;
-    'content-type'?: string | undefined;
-    /**
-     * Always an array in Node. Duplicates are added to it.
-     * Not necessarily true for other environments, make sure
-     * to check the type during runtime.
-     */
-    'set-cookie'?: string | string[] | undefined;
-    [key: string]: string | string[] | undefined;
-}
-/**
- * Server agnostic request interface containing the raw request
- * which is server dependant.
- *
- * @category Common
- */
-export interface Request<RawRequest> {
-    readonly method: string;
-    readonly url: string;
-    readonly headers: RequestHeaders;
-    readonly body: string | Record<string, unknown> | null;
-    /**
-     * The raw request itself from the implementing server.
-     *
-     * For example: `express.Request` when using Express, or maybe
-     * `http.IncomingMessage` when just using Node with `http.createServer`.
-     */
-    readonly raw: RawRequest;
-}
 /**
  * Parameters for GraphQL's request for execution.
  *
@@ -52,47 +16,6 @@ export interface RequestParams {
     variables?: Record<string, unknown> | undefined;
     extensions?: Record<string, unknown> | undefined;
 }
-/**
- * The response headers that get returned from graphql-http.
- *
- * @category Common
- */
-export declare type ResponseHeaders = {
-    accept?: string;
-    allow?: string;
-    'content-type'?: string;
-} & Record<string, string>;
-/**
- * Server agnostic response body returned from `graphql-http` needing
- * to be coerced to the server implementation in use.
- *
- * @category Common
- */
-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
- */
-export interface ResponseInit {
-    readonly status: number;
-    readonly statusText: string;
-    readonly headers?: ResponseHeaders;
-}
-/**
- * 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
- */
-export declare type Response = readonly [body: ResponseBody | null, init: ResponseInit];
-/**
- * Checks whether the passed value is the `graphql-http` server agnostic response.
- *
- * @category Common
- */
-export declare function isResponse(val: unknown): val is Response;
 /**
  * A representation of any set of values over any amount of time.
  *

package/lib/common.js

@@ -5,17 +5,3 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isResponse = void 0;
-const utils_1 = require("./utils");
-/**
- * Checks whether the passed value is the `graphql-http` server agnostic response.
- *
- * @category Common
- */
-function isResponse(val) {
-    // TODO: make sure the contents of init match ResponseInit
-    return (Array.isArray(val) &&
-        (typeof val[0] === 'string' || val[0] === null) &&
-        (0, utils_1.isObject)(val[1]));
-}
-exports.isResponse = isResponse;

package/lib/common.mjs

@@ -3,15 +3,4 @@
  * common
  *
  */
-import { isObject } from './utils.mjs';
-/**
- * Checks whether the passed value is the `graphql-http` server agnostic response.
- *
- * @category Common
- */
-export function isResponse(val) {
-    // TODO: make sure the contents of init match ResponseInit
-    return (Array.isArray(val) &&
-        (typeof val[0] === 'string' || val[0] === null) &&
-        isObject(val[1]));
-}
+export {};

package/lib/handler.d.ts

@@ -4,7 +4,94 @@
  *
  */
 import { ExecutionArgs, ExecutionResult, GraphQLSchema, validate as graphqlValidate, execute as graphqlExecute, parse as graphqlParse, getOperationAST as graphqlGetOperationAST, GraphQLError } from 'graphql';
-import { Request, RequestParams, Response } from './common';
+import { RequestParams } from './common';
+/**
+ * The incoming request headers the implementing server should provide.
+ *
+ * @category Common
+ */
+export interface RequestHeaders {
+    accept?: string | undefined;
+    allow?: string | undefined;
+    'content-type'?: string | undefined;
+    /**
+     * Always an array in Node. Duplicates are added to it.
+     * Not necessarily true for other environments, make sure
+     * to check the type during runtime.
+     */
+    'set-cookie'?: string | string[] | undefined;
+    [key: string]: string | string[] | undefined;
+}
+/**
+ * Server agnostic request interface containing the raw request
+ * which is server dependant.
+ *
+ * @category Common
+ */
+export interface Request<RawRequest, Context> {
+    readonly method: string;
+    readonly url: string;
+    readonly headers: RequestHeaders;
+    /**
+     * Parsed request body or a parser function.
+     *
+     * If the provided function throws, the error message "Unparsable JSON body" will
+     * be in the erroneous response.
+     */
+    readonly body: string | Record<string, unknown> | null | (() => string | Record<string, unknown> | null | Promise<string | Record<string, unknown> | null>);
+    /**
+     * The raw request itself from the implementing server.
+     *
+     * For example: `express.Request` when using Express, or maybe
+     * `http.IncomingMessage` when just using Node with `http.createServer`.
+     */
+    readonly raw: RawRequest;
+    /**
+     * Context value about the incoming request, you're free to pass any information here.
+     */
+    readonly context: Context;
+}
+/**
+ * The response headers that get returned from graphql-http.
+ *
+ * @category Common
+ */
+export declare type ResponseHeaders = {
+    accept?: string;
+    allow?: string;
+    'content-type'?: string;
+} & Record<string, string>;
+/**
+ * Server agnostic response body returned from `graphql-http` needing
+ * to be coerced to the server implementation in use.
+ *
+ * @category Common
+ */
+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
+ */
+export interface ResponseInit {
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers?: ResponseHeaders;
+}
+/**
+ * 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
+ */
+export declare type Response = readonly [body: ResponseBody | null, init: ResponseInit];
+/**
+ * Checks whether the passed value is the `graphql-http` server agnostic response.
+ *
+ * @category Common
+ */
+export declare function isResponse(val: unknown): val is Response;
 /**
  * A concrete GraphQL execution context value type.
  *
@@ -17,7 +104,7 @@ import { Request, RequestParams, Response } from './common';
  */
 export declare type ExecutionContext = object | symbol | number | string | boolean | undefined | null;
 /** @category Server */
-export interface HandlerOptions<RawRequest = unknown> {
+export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
     /**
      * The GraphQL schema on which the operations will
      * be executed and validated against.
@@ -34,16 +121,18 @@ export interface HandlerOptions<RawRequest = unknown> {
      * you should do by returning a `Request` argument which will stop
      * further execution.
      */
-    schema?: GraphQLSchema | ((req: Request<RawRequest>, args: Omit<ExecutionArgs, 'schema'>) => Promise<GraphQLSchema | Response> | GraphQLSchema | Response);
+    schema?: GraphQLSchema | ((req: Request<RawRequest, Context>, args: Omit<ExecutionArgs, '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>, args: ExecutionArgs) => Promise<ExecutionContext | Response> | ExecutionContext | Response);
+    context?: ExecutionContext | ((req: Request<RawRequest, Context>, args: ExecutionArgs) => Promise<ExecutionContext | Response> | ExecutionContext | Response);
     /**
      * A custom GraphQL validate function allowing you to apply your
      * own validation rules.
+     *
+     * Will not be used when implementing a custom `onSubscribe`.
      */
     validate?: typeof graphqlValidate;
     /**
@@ -63,10 +152,16 @@ export interface HandlerOptions<RawRequest = unknown> {
      * The subscribe callback executed right after processing the request
      * before proceeding with the GraphQL operation execution.
      *
+     * If you return `ExecutionResult` from the callback, it will be used
+     * directly for responding to the request. Useful for implementing a response
+     * cache.
+     *
      * If you return `ExecutionArgs` from the callback, it will be used instead of
      * trying to build one internally. In this case, you are responsible for providing
      * a ready set of arguments which will be directly plugged in the operation execution.
      *
+     * You *must* validate the `ExecutionArgs` yourself if returning them.
+     *
      * If you return an array of `GraphQLError` from the callback, they will be reported
      * to the client while complying with the spec.
      *
@@ -81,7 +176,7 @@ export interface HandlerOptions<RawRequest = unknown> {
      * you should do by returning a `Request` argument which will stop
      * further execution.
      */
-    onSubscribe?: (req: Request<RawRequest>, params: RequestParams) => Promise<ExecutionArgs | GraphQLError[] | Response | void> | ExecutionArgs | GraphQLError[] | Response | void;
+    onSubscribe?: (req: Request<RawRequest, Context>, params: RequestParams) => Promise<ExecutionResult | ExecutionArgs | readonly GraphQLError[] | Response | void> | ExecutionResult | ExecutionArgs | readonly GraphQLError[] | Response | void;
     /**
      * Executed after the operation call resolves.
      *
@@ -95,7 +190,7 @@ export interface HandlerOptions<RawRequest = unknown> {
      * you should do by returning a `Request` argument which will stop
      * further execution.
      */
-    onOperation?: (req: Request<RawRequest>, args: ExecutionArgs, result: ExecutionResult) => Promise<ExecutionResult | Response | void> | ExecutionResult | Response | void;
+    onOperation?: (req: Request<RawRequest, Context>, args: ExecutionArgs, result: ExecutionResult) => Promise<ExecutionResult | Response | void> | ExecutionResult | Response | void;
 }
 /**
  * The ready-to-use handler. Simply plug it in your favourite HTTP framework
@@ -107,7 +202,7 @@ export interface HandlerOptions<RawRequest = unknown> {
  *
  * @category Server
  */
-export declare type Handler<RawRequest = unknown> = (req: Request<RawRequest>) => Promise<Response>;
+export declare type Handler<RawRequest = unknown, Context = unknown> = (req: Request<RawRequest, Context>) => Promise<Response>;
 /**
  * Makes a GraphQL over HTTP Protocol compliant server handler. The handler can
  * be used with your favourite server library.
@@ -163,4 +258,28 @@ export declare type Handler<RawRequest = unknown> = (req: Request<RawRequest>) =
  *
  * @category Server
  */
-export declare function createHandler<RawRequest = unknown>(options: HandlerOptions<RawRequest>): Handler<RawRequest>;
+export declare function createHandler<RawRequest = unknown, Context = unknown>(options: HandlerOptions<RawRequest, Context>): Handler<RawRequest, Context>;
+/**
+ * Request's Media-Type that the server accepts.
+ *
+ * @category Server
+ */
+export declare type AcceptableMediaType = 'application/graphql-response+json' | 'application/json';
+/**
+ * Inspects the request and detects the appropriate/acceptable Media-Type
+ * looking at the `Accept` header while complying with the GraphQL over HTTP Protocol.
+ *
+ * @category Server
+ */
+export declare function getAcceptableMediaType(acceptHeader: string | null | undefined): AcceptableMediaType | null;
+/**
+ * Creates an appropriate GraphQL over HTTP response following the provided arguments.
+ *
+ * If the first argument is an `ExecutionResult`, the operation will be treated as "successful".
+ *
+ * If the first argument is _any_ object without the `data` field, it will be treated as an error (as per the spec)
+ * and the response will be constructed with the help of `acceptedMediaType` complying with the GraphQL over HTTP Protocol.
+ *
+ * @category Server
+ */
+export declare function makeResponse(resultOrErrors: Readonly<ExecutionResult> | Readonly<GraphQLError[]> | Readonly<GraphQLError>, acceptedMediaType: AcceptableMediaType): Response;

package/lib/handler.js

@@ -5,10 +5,21 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHandler = void 0;
+exports.makeResponse = exports.getAcceptableMediaType = exports.createHandler = exports.isResponse = void 0;
 const graphql_1 = require("graphql");
-const common_1 = require("./common");
 const utils_1 = require("./utils");
+/**
+ * Checks whether the passed value is the `graphql-http` server agnostic response.
+ *
+ * @category Common
+ */
+function isResponse(val) {
+    // TODO: make sure the contents of init match ResponseInit
+    return (Array.isArray(val) &&
+        (typeof val[0] === 'string' || val[0] === null) &&
+        (0, utils_1.isObject)(val[1]));
+}
+exports.isResponse = isResponse;
 /**
  * Makes a GraphQL over HTTP Protocol compliant server handler. The handler can
  * be used with your favourite server library.
@@ -81,28 +92,7 @@ function createHandler(options) {
                 },
             ];
         }
-        let acceptedMediaType;
-        const accepts = (req.headers.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/json' && charset === 'charset=utf8') {
-                acceptedMediaType = 'application/json';
-                break;
-            }
-            if ((mediaType === 'application/graphql+json' ||
-                mediaType === 'application/*' ||
-                mediaType === '*/*') &&
-                charset === 'charset=utf8') {
-                acceptedMediaType = 'application/graphql+json';
-                break;
-            }
-        }
+        const acceptedMediaType = getAcceptableMediaType(req.headers.accept);
         if (!acceptedMediaType) {
             return [
                 null,
@@ -110,7 +100,7 @@ function createHandler(options) {
                     status: 406,
                     statusText: 'Not Acceptable',
                     headers: {
-                        accept: 'application/graphql+json; charset=utf-8, application/json; charset=utf-8',
+                        accept: 'application/graphql-response+json; charset=utf-8, application/json; charset=utf-8',
                     },
                 },
             ];
@@ -152,16 +142,21 @@ function createHandler(options) {
                         if (!req.body) {
                             throw new Error('Missing body');
                         }
+                        let data;
                         try {
-                            const data = typeof req.body === 'string' ? JSON.parse(req.body) : req.body;
-                            partParams.operationName = data.operationName;
-                            partParams.query = data.query;
-                            partParams.variables = data.variables;
-                            partParams.extensions = data.extensions;
+                            const body = typeof req.body === 'function' ? await req.body() : req.body;
+                            data = typeof body === 'string' ? JSON.parse(body) : body;
                         }
-                        catch (_d) {
+                        catch (err) {
                             throw new Error('Unparsable JSON body');
                         }
+                        if (!(0, utils_1.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
@@ -173,8 +168,10 @@ function createHandler(options) {
                         },
                     ];
             }
-            if (!partParams.query)
+            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))) {
@@ -189,40 +186,15 @@ function createHandler(options) {
             params = partParams;
         }
         catch (err) {
-            return [
-                err.message,
-                Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
-                    ? {
-                        status: 200,
-                        statusText: 'OK',
-                    }
-                    : {
-                        status: 400,
-                        statusText: 'Bad Request',
-                    })), { statusText: 'Bad Request' }),
-            ];
+            return makeResponse(new graphql_1.GraphQLError(err.message), acceptedMediaType);
         }
         let args;
         const maybeResErrsOrArgs = await (onSubscribe === null || onSubscribe === void 0 ? void 0 : onSubscribe(req, params));
-        if ((0, common_1.isResponse)(maybeResErrsOrArgs))
+        if (isResponse(maybeResErrsOrArgs))
             return maybeResErrsOrArgs;
-        else if ((0, utils_1.areGraphQLErrors)(maybeResErrsOrArgs))
-            return [
-                JSON.stringify({ errors: maybeResErrsOrArgs }),
-                Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
-                    ? {
-                        status: 200,
-                        statusText: 'OK',
-                    }
-                    : {
-                        status: 400,
-                        statusText: 'Bad Request',
-                    })), { headers: {
-                        'content-type': acceptedMediaType === 'application/json'
-                            ? 'application/json; charset=utf-8'
-                            : 'application/graphql+json; charset=utf-8',
-                    } }),
-            ];
+        else if ((0, utils_1.isExecutionResult)(maybeResErrsOrArgs) ||
+            (0, utils_1.areGraphQLErrors)(maybeResErrsOrArgs))
+            return makeResponse(maybeResErrsOrArgs, acceptedMediaType);
         else if (maybeResErrsOrArgs)
             args = maybeResErrsOrArgs;
         else {
@@ -234,22 +206,7 @@ function createHandler(options) {
                 document = parse(query);
             }
             catch (err) {
-                return [
-                    JSON.stringify({ errors: [err] }),
-                    Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
-                        ? {
-                            status: 200,
-                            statusText: 'OK',
-                        }
-                        : {
-                            status: 400,
-                            statusText: 'Bad Request',
-                        })), { statusText: 'Bad Request', headers: {
-                            'content-type': acceptedMediaType === 'application/json'
-                                ? 'application/json; charset=utf-8'
-                                : 'application/graphql+json; charset=utf-8',
-                        } }),
-                ];
+                return makeResponse(err, acceptedMediaType);
             }
             const argsWithoutSchema = {
                 operationName,
@@ -258,13 +215,17 @@ function createHandler(options) {
             };
             if (typeof schema === 'function') {
                 const resOrSchema = await schema(req, argsWithoutSchema);
-                if ((0, common_1.isResponse)(resOrSchema))
+                if (isResponse(resOrSchema))
                     return resOrSchema;
                 args = Object.assign(Object.assign({}, argsWithoutSchema), { schema: resOrSchema });
             }
             else {
                 args = Object.assign(Object.assign({}, argsWithoutSchema), { schema });
             }
+            const validationErrs = validate(args.schema, args.document);
+            if (validationErrs.length) {
+                return makeResponse(validationErrs, acceptedMediaType);
+            }
         }
         let operation;
         try {
@@ -273,34 +234,19 @@ function createHandler(options) {
                 throw null;
             operation = ast.operation;
         }
-        catch (_e) {
-            return [
-                'Unable to detect operation AST',
-                Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
-                    ? {
-                        status: 200,
-                        statusText: 'OK',
-                    }
-                    : {
-                        status: 400,
-                        statusText: 'Bad Request',
-                    })), { statusText: 'Bad Request' }),
-            ];
+        catch (_d) {
+            return makeResponse(new graphql_1.GraphQLError('Unable to detect operation AST'), acceptedMediaType);
         }
         if (operation === 'subscription') {
-            return [
-                'Subscriptions are not supported',
-                {
-                    status: 400,
-                    statusText: 'Bad Request',
-                },
-            ];
+            return makeResponse(new graphql_1.GraphQLError('Subscriptions are not supported'), acceptedMediaType);
         }
         // mutations cannot happen over GETs
         // https://graphql.github.io/graphql-over-http/draft/#sel-CALFJRPAAELBAAxwP
         if (operation === 'mutation' && method === 'GET') {
             return [
-                'Cannot perform mutations over GET',
+                JSON.stringify({
+                    errors: [new graphql_1.GraphQLError('Cannot perform mutations over GET')],
+                }),
                 {
                     status: 405,
                     statusText: 'Method Not Allowed',
@@ -312,47 +258,101 @@ function createHandler(options) {
         }
         if (!('contextValue' in args)) {
             const maybeResOrContext = typeof context === 'function' ? await context(req, args) : context;
-            if ((0, common_1.isResponse)(maybeResOrContext))
+            if (isResponse(maybeResOrContext))
                 return maybeResOrContext;
             args.contextValue = maybeResOrContext;
         }
-        const validationErrs = validate(args.schema, args.document);
-        if (validationErrs.length) {
-            return [
-                JSON.stringify({ errors: validationErrs }),
-                Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
-                    ? {
-                        status: 200,
-                        statusText: 'OK',
-                    }
-                    : {
-                        status: 400,
-                        statusText: 'Bad Request',
-                    })), { headers: {
-                        'content-type': acceptedMediaType === 'application/json'
-                            ? 'application/json; charset=utf-8'
-                            : 'application/graphql+json; charset=utf-8',
-                    } }),
-            ];
-        }
         let result = await execute(args);
-        const maybeResOrResult = await (onOperation === null || onOperation === void 0 ? void 0 : onOperation(req, args, result));
-        if ((0, common_1.isResponse)(maybeResOrResult))
-            return maybeResOrResult;
-        else if (maybeResOrResult)
-            result = maybeResOrResult;
+        const maybeResponseOrResult = await (onOperation === null || onOperation === void 0 ? void 0 : onOperation(req, args, result));
+        if (isResponse(maybeResponseOrResult))
+            return maybeResponseOrResult;
+        else if (maybeResponseOrResult)
+            result = maybeResponseOrResult;
+        if ((0, utils_1.isAsyncIterable)(result)) {
+            return makeResponse(new graphql_1.GraphQLError('Subscriptions are not supported'), acceptedMediaType);
+        }
+        return makeResponse(result, acceptedMediaType);
+    };
+}
+exports.createHandler = createHandler;
+/**
+ * Inspects the request and detects the appropriate/acceptable Media-Type
+ * looking at the `Accept` header while complying with the GraphQL over HTTP Protocol.
+ *
+ * @category Server
+ */
+function getAcceptableMediaType(acceptHeader) {
+    let acceptedMediaType = null;
+    const accepts = (acceptHeader || '*/*')
+        .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/json' && charset === 'charset=utf8') {
+            acceptedMediaType = 'application/json';
+            break;
+        }
+        if ((mediaType === 'application/graphql-response+json' ||
+            mediaType === 'application/*' ||
+            mediaType === '*/*') &&
+            charset === 'charset=utf8') {
+            acceptedMediaType = 'application/graphql-response+json';
+            break;
+        }
+    }
+    return acceptedMediaType;
+}
+exports.getAcceptableMediaType = getAcceptableMediaType;
+/**
+ * Creates an appropriate GraphQL over HTTP response following the provided arguments.
+ *
+ * If the first argument is an `ExecutionResult`, the operation will be treated as "successful".
+ *
+ * If the first argument is _any_ object without the `data` field, it will be treated as an error (as per the spec)
+ * and the response will be constructed with the help of `acceptedMediaType` complying with the GraphQL over HTTP Protocol.
+ *
+ * @category Server
+ */
+function makeResponse(resultOrErrors, acceptedMediaType) {
+    if ((0, utils_1.isExecutionResult)(resultOrErrors)) {
         return [
-            JSON.stringify(result),
+            JSON.stringify(resultOrErrors),
             {
                 status: 200,
                 statusText: 'OK',
                 headers: {
                     'content-type': acceptedMediaType === 'application/json'
                         ? 'application/json; charset=utf-8'
-                        : 'application/graphql+json; charset=utf-8',
+                        : 'application/graphql-response+json; charset=utf-8',
                 },
             },
         ];
-    };
+    }
+    return [
+        JSON.stringify({
+            errors: Array.isArray(resultOrErrors)
+                ? (0, utils_1.isObject)(resultOrErrors)
+                    ? resultOrErrors
+                    : new graphql_1.GraphQLError(String(resultOrErrors))
+                : [resultOrErrors],
+        }),
+        Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
+            ? {
+                status: 200,
+                statusText: 'OK',
+            }
+            : {
+                status: 400,
+                statusText: 'Bad Request',
+            })), { headers: {
+                'content-type': acceptedMediaType === 'application/json'
+                    ? 'application/json; charset=utf-8'
+                    : 'application/graphql-response+json; charset=utf-8',
+            } }),
+    ];
 }
-exports.createHandler = createHandler;
+exports.makeResponse = makeResponse;

package/lib/handler.mjs

@@ -3,9 +3,19 @@
  * handler
  *
  */
-import { validate as graphqlValidate, execute as graphqlExecute, parse as graphqlParse, getOperationAST as graphqlGetOperationAST, } from 'graphql';
-import { isResponse } from './common.mjs';
-import { areGraphQLErrors } from './utils.mjs';
+import { validate as graphqlValidate, execute as graphqlExecute, parse as graphqlParse, getOperationAST as graphqlGetOperationAST, GraphQLError, } from 'graphql';
+import { areGraphQLErrors, isAsyncIterable, isExecutionResult, isObject, } from './utils.mjs';
+/**
+ * Checks whether the passed value is the `graphql-http` server agnostic response.
+ *
+ * @category Common
+ */
+export function isResponse(val) {
+    // TODO: make sure the contents of init match ResponseInit
+    return (Array.isArray(val) &&
+        (typeof val[0] === 'string' || val[0] === null) &&
+        isObject(val[1]));
+}
 /**
  * Makes a GraphQL over HTTP Protocol compliant server handler. The handler can
  * be used with your favourite server library.
@@ -78,28 +88,7 @@ export function createHandler(options) {
                 },
             ];
         }
-        let acceptedMediaType;
-        const accepts = (req.headers.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/json' && charset === 'charset=utf8') {
-                acceptedMediaType = 'application/json';
-                break;
-            }
-            if ((mediaType === 'application/graphql+json' ||
-                mediaType === 'application/*' ||
-                mediaType === '*/*') &&
-                charset === 'charset=utf8') {
-                acceptedMediaType = 'application/graphql+json';
-                break;
-            }
-        }
+        const acceptedMediaType = getAcceptableMediaType(req.headers.accept);
         if (!acceptedMediaType) {
             return [
                 null,
@@ -107,7 +96,7 @@ export function createHandler(options) {
                     status: 406,
                     statusText: 'Not Acceptable',
                     headers: {
-                        accept: 'application/graphql+json; charset=utf-8, application/json; charset=utf-8',
+                        accept: 'application/graphql-response+json; charset=utf-8, application/json; charset=utf-8',
                     },
                 },
             ];
@@ -149,16 +138,21 @@ export function createHandler(options) {
                         if (!req.body) {
                             throw new Error('Missing body');
                         }
+                        let data;
                         try {
-                            const data = typeof req.body === 'string' ? JSON.parse(req.body) : req.body;
-                            partParams.operationName = data.operationName;
-                            partParams.query = data.query;
-                            partParams.variables = data.variables;
-                            partParams.extensions = data.extensions;
+                            const body = typeof req.body === 'function' ? await req.body() : req.body;
+                            data = typeof body === 'string' ? JSON.parse(body) : body;
                         }
-                        catch (_d) {
+                        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
@@ -170,8 +164,10 @@ export function createHandler(options) {
                         },
                     ];
             }
-            if (!partParams.query)
+            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))) {
@@ -186,40 +182,15 @@ export function createHandler(options) {
             params = partParams;
         }
         catch (err) {
-            return [
-                err.message,
-                Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
-                    ? {
-                        status: 200,
-                        statusText: 'OK',
-                    }
-                    : {
-                        status: 400,
-                        statusText: 'Bad Request',
-                    })), { statusText: 'Bad Request' }),
-            ];
+            return makeResponse(new GraphQLError(err.message), acceptedMediaType);
         }
         let args;
         const maybeResErrsOrArgs = await (onSubscribe === null || onSubscribe === void 0 ? void 0 : onSubscribe(req, params));
         if (isResponse(maybeResErrsOrArgs))
             return maybeResErrsOrArgs;
-        else if (areGraphQLErrors(maybeResErrsOrArgs))
-            return [
-                JSON.stringify({ errors: maybeResErrsOrArgs }),
-                Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
-                    ? {
-                        status: 200,
-                        statusText: 'OK',
-                    }
-                    : {
-                        status: 400,
-                        statusText: 'Bad Request',
-                    })), { headers: {
-                        'content-type': acceptedMediaType === 'application/json'
-                            ? 'application/json; charset=utf-8'
-                            : 'application/graphql+json; charset=utf-8',
-                    } }),
-            ];
+        else if (isExecutionResult(maybeResErrsOrArgs) ||
+            areGraphQLErrors(maybeResErrsOrArgs))
+            return makeResponse(maybeResErrsOrArgs, acceptedMediaType);
         else if (maybeResErrsOrArgs)
             args = maybeResErrsOrArgs;
         else {
@@ -231,22 +202,7 @@ export function createHandler(options) {
                 document = parse(query);
             }
             catch (err) {
-                return [
-                    JSON.stringify({ errors: [err] }),
-                    Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
-                        ? {
-                            status: 200,
-                            statusText: 'OK',
-                        }
-                        : {
-                            status: 400,
-                            statusText: 'Bad Request',
-                        })), { statusText: 'Bad Request', headers: {
-                            'content-type': acceptedMediaType === 'application/json'
-                                ? 'application/json; charset=utf-8'
-                                : 'application/graphql+json; charset=utf-8',
-                        } }),
-                ];
+                return makeResponse(err, acceptedMediaType);
             }
             const argsWithoutSchema = {
                 operationName,
@@ -262,6 +218,10 @@ export function createHandler(options) {
             else {
                 args = Object.assign(Object.assign({}, argsWithoutSchema), { schema });
             }
+            const validationErrs = validate(args.schema, args.document);
+            if (validationErrs.length) {
+                return makeResponse(validationErrs, acceptedMediaType);
+            }
         }
         let operation;
         try {
@@ -270,34 +230,19 @@ export function createHandler(options) {
                 throw null;
             operation = ast.operation;
         }
-        catch (_e) {
-            return [
-                'Unable to detect operation AST',
-                Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
-                    ? {
-                        status: 200,
-                        statusText: 'OK',
-                    }
-                    : {
-                        status: 400,
-                        statusText: 'Bad Request',
-                    })), { statusText: 'Bad Request' }),
-            ];
+        catch (_d) {
+            return makeResponse(new GraphQLError('Unable to detect operation AST'), acceptedMediaType);
         }
         if (operation === 'subscription') {
-            return [
-                'Subscriptions are not supported',
-                {
-                    status: 400,
-                    statusText: 'Bad Request',
-                },
-            ];
+            return makeResponse(new GraphQLError('Subscriptions are not supported'), acceptedMediaType);
         }
         // mutations cannot happen over GETs
         // https://graphql.github.io/graphql-over-http/draft/#sel-CALFJRPAAELBAAxwP
         if (operation === 'mutation' && method === 'GET') {
             return [
-                'Cannot perform mutations over GET',
+                JSON.stringify({
+                    errors: [new GraphQLError('Cannot perform mutations over GET')],
+                }),
                 {
                     status: 405,
                     statusText: 'Method Not Allowed',
@@ -313,42 +258,94 @@ export function createHandler(options) {
                 return maybeResOrContext;
             args.contextValue = maybeResOrContext;
         }
-        const validationErrs = validate(args.schema, args.document);
-        if (validationErrs.length) {
-            return [
-                JSON.stringify({ errors: validationErrs }),
-                Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
-                    ? {
-                        status: 200,
-                        statusText: 'OK',
-                    }
-                    : {
-                        status: 400,
-                        statusText: 'Bad Request',
-                    })), { headers: {
-                        'content-type': acceptedMediaType === 'application/json'
-                            ? 'application/json; charset=utf-8'
-                            : 'application/graphql+json; charset=utf-8',
-                    } }),
-            ];
-        }
         let result = await execute(args);
-        const maybeResOrResult = await (onOperation === null || onOperation === void 0 ? void 0 : onOperation(req, args, result));
-        if (isResponse(maybeResOrResult))
-            return maybeResOrResult;
-        else if (maybeResOrResult)
-            result = maybeResOrResult;
+        const maybeResponseOrResult = await (onOperation === null || onOperation === void 0 ? void 0 : onOperation(req, args, result));
+        if (isResponse(maybeResponseOrResult))
+            return maybeResponseOrResult;
+        else if (maybeResponseOrResult)
+            result = maybeResponseOrResult;
+        if (isAsyncIterable(result)) {
+            return makeResponse(new GraphQLError('Subscriptions are not supported'), acceptedMediaType);
+        }
+        return makeResponse(result, acceptedMediaType);
+    };
+}
+/**
+ * Inspects the request and detects the appropriate/acceptable Media-Type
+ * looking at the `Accept` header while complying with the GraphQL over HTTP Protocol.
+ *
+ * @category Server
+ */
+export function getAcceptableMediaType(acceptHeader) {
+    let acceptedMediaType = null;
+    const accepts = (acceptHeader || '*/*')
+        .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/json' && charset === 'charset=utf8') {
+            acceptedMediaType = 'application/json';
+            break;
+        }
+        if ((mediaType === 'application/graphql-response+json' ||
+            mediaType === 'application/*' ||
+            mediaType === '*/*') &&
+            charset === 'charset=utf8') {
+            acceptedMediaType = 'application/graphql-response+json';
+            break;
+        }
+    }
+    return acceptedMediaType;
+}
+/**
+ * Creates an appropriate GraphQL over HTTP response following the provided arguments.
+ *
+ * If the first argument is an `ExecutionResult`, the operation will be treated as "successful".
+ *
+ * If the first argument is _any_ object without the `data` field, it will be treated as an error (as per the spec)
+ * and the response will be constructed with the help of `acceptedMediaType` complying with the GraphQL over HTTP Protocol.
+ *
+ * @category Server
+ */
+export function makeResponse(resultOrErrors, acceptedMediaType) {
+    if (isExecutionResult(resultOrErrors)) {
         return [
-            JSON.stringify(result),
+            JSON.stringify(resultOrErrors),
             {
                 status: 200,
                 statusText: 'OK',
                 headers: {
                     'content-type': acceptedMediaType === 'application/json'
                         ? 'application/json; charset=utf-8'
-                        : 'application/graphql+json; charset=utf-8',
+                        : 'application/graphql-response+json; charset=utf-8',
                 },
             },
         ];
-    };
+    }
+    return [
+        JSON.stringify({
+            errors: Array.isArray(resultOrErrors)
+                ? isObject(resultOrErrors)
+                    ? resultOrErrors
+                    : new GraphQLError(String(resultOrErrors))
+                : [resultOrErrors],
+        }),
+        Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
+            ? {
+                status: 200,
+                statusText: 'OK',
+            }
+            : {
+                status: 400,
+                statusText: 'Bad Request',
+            })), { headers: {
+                'content-type': acceptedMediaType === 'application/json'
+                    ? 'application/json; charset=utf-8'
+                    : 'application/graphql-response+json; charset=utf-8',
+            } }),
+    ];
 }

package/lib/utils.d.ts

@@ -3,8 +3,12 @@
  * utils
  *
  */
-import type { GraphQLError } from 'graphql';
+import type { ExecutionResult, GraphQLError } from 'graphql';
 /** @private */
-export declare function isObject(val: unknown): val is Record<PropertyKey, unknown>;
+export declare function isObject(val: unknown): val is Record<PropertyKey, any>;
 /** @private */
-export declare function areGraphQLErrors(obj: unknown): obj is GraphQLError[];
+export declare function areGraphQLErrors(obj: unknown): obj is readonly GraphQLError[];
+/** @private */
+export declare function isExecutionResult(val: unknown): val is ExecutionResult;
+/** @private */
+export declare function isAsyncIterable<T = unknown>(val: unknown): val is AsyncIterable<T>;

package/lib/utils.js

@@ -5,7 +5,7 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.areGraphQLErrors = exports.isObject = void 0;
+exports.isAsyncIterable = exports.isExecutionResult = exports.areGraphQLErrors = exports.isObject = void 0;
 /** @private */
 function isObject(val) {
     return typeof val === 'object' && val !== null;
@@ -20,3 +20,14 @@ function areGraphQLErrors(obj) {
         obj.every((ob) => 'message' in ob));
 }
 exports.areGraphQLErrors = areGraphQLErrors;
+/** @private */
+function isExecutionResult(val) {
+    return (isObject(val) &&
+        ('data' in val || ('data' in val && val.data == null && 'errors' in val)));
+}
+exports.isExecutionResult = isExecutionResult;
+/** @private */
+function isAsyncIterable(val) {
+    return typeof Object(val)[Symbol.asyncIterator] === 'function';
+}
+exports.isAsyncIterable = isAsyncIterable;

package/lib/utils.mjs

@@ -15,3 +15,12 @@ export function areGraphQLErrors(obj) {
         // error has at least a message
         obj.every((ob) => 'message' in ob));
 }
+/** @private */
+export function isExecutionResult(val) {
+    return (isObject(val) &&
+        ('data' in val || ('data' in val && val.data == null && 'errors' in val)));
+}
+/** @private */
+export function isAsyncIterable(val) {
+    return typeof Object(val)[Symbol.asyncIterator] === 'function';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-http",
-  "version": "1.1.0",
+  "version": "1.4.0",
   "description": "Simple, pluggable, zero-dependency, GraphQL over HTTP Protocol compliant server and client",
   "keywords": [
     "graphql",
@@ -75,11 +75,11 @@
     "@rollup/plugin-typescript": "^8.3.4",
     "@semantic-release/changelog": "^6.0.1",
     "@semantic-release/git": "^10.0.1",
-    "@types/jest": "^28.1.6",
-    "@typescript-eslint/eslint-plugin": "^5.32.0",
-    "@typescript-eslint/parser": "^5.32.0",
+    "@types/jest": "^28.1.7",
+    "@typescript-eslint/eslint-plugin": "^5.33.1",
+    "@typescript-eslint/parser": "^5.33.1",
     "babel-jest": "^28.1.3",
-    "eslint": "^8.21.0",
+    "eslint": "^8.22.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-prettier": "^4.2.1",
     "graphql": "^16.5.0",
@@ -88,7 +88,7 @@
     "node-fetch": "^3.2.10",
     "prettier": "^2.7.1",
     "replacestream": "^4.0.3",
-    "rollup": "^2.77.2",
+    "rollup": "^2.78.0",
     "rollup-plugin-terser": "^7.0.2",
     "semantic-release": "^19.0.3",
     "tslib": "^2.4.0",

package/umd/graphql-http.js

@@ -14,23 +14,6 @@
         return typeof val === 'object' && val !== null;
     }
 
-    /**
-     *
-     * common
-     *
-     */
-    /**
-     * Checks whether the passed value is the `graphql-http` server agnostic response.
-     *
-     * @category Common
-     */
-    function isResponse(val) {
-        // TODO: make sure the contents of init match ResponseInit
-        return (Array.isArray(val) &&
-            (typeof val[0] === 'string' || val[0] === null) &&
-            isObject(val[1]));
-    }
-
     /**
      *
      * client
@@ -118,7 +101,7 @@
                                 res = await fetchFn(url, {
                                     signal: control.signal,
                                     method: 'POST',
-                                    headers: Object.assign(Object.assign({}, headers), { 'content-type': 'application/json; charset=utf-8', accept: 'application/graphql+json, application/json' }),
+                                    headers: Object.assign(Object.assign({}, headers), { 'content-type': 'application/json; charset=utf-8', accept: 'application/graphql-response+json, application/json' }),
                                     credentials,
                                     referrer,
                                     referrerPolicy,
@@ -135,7 +118,7 @@
                             const contentType = res.headers.get('content-type');
                             if (!contentType)
                                 throw new Error('Missing response content-type');
-                            if (!contentType.includes('application/graphql+json') &&
+                            if (!contentType.includes('application/graphql-response+json') &&
                                 !contentType.includes('application/json')) {
                                 throw new Error(`Unsupported response content-type ${contentType}`);
                             }
@@ -201,7 +184,6 @@
 
     exports.NetworkError = NetworkError;
     exports.createClient = createClient;
-    exports.isResponse = isResponse;
 
     Object.defineProperty(exports, '__esModule', { value: true });
 

package/umd/graphql-http.min.js

@@ -1 +1 @@
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).graphqlHttp={})}(this,(function(e){"use strict";function t(e){return"object"==typeof e&&null!==e}class r extends Error{constructor(e){let r,o;var n;t(n=e)&&"boolean"==typeof n.ok&&"number"==typeof n.status&&"string"==typeof n.statusText?(o=e,r="Server responded with "+e.status+": "+e.statusText):r=e instanceof Error?e.message:String(e),super(r),this.name=this.constructor.name,this.response=o}}e.NetworkError=r,e.createClient=function(e){const{credentials:t="same-origin",referrer:o,referrerPolicy:n,shouldRetry:s=(()=>!1)}=e,i=e.fetchFn||fetch,a=e.abortControllerImpl||AbortController,c=(()=>{let e=!1;const t=[];return{get disposed(){return e},onDispose:r=>e?(setTimeout((()=>r()),0),()=>{}):(t.push(r),()=>{t.splice(t.indexOf(r),1)}),dispose(){if(!e){e=!0;for(const e of[...t])e()}}}})();return{subscribe(l,p){if(c.disposed)throw new Error("Client has been disposed");const f=new a,u=c.onDispose((()=>{u(),f.abort()}));return(async()=>{var a;let c=null,u=0;for(;;){if(c){const e=await s(c,u);if(f.signal.aborted)return;if(!e)throw c;u++}try{const s="function"==typeof e.url?await e.url(l):e.url;if(f.signal.aborted)return;const c="function"==typeof e.headers?await e.headers():null!==(a=e.headers)&&void 0!==a?a:{};if(f.signal.aborted)return;let u;try{u=await i(s,{signal:f.signal,method:"POST",headers:Object.assign(Object.assign({},c),{"content-type":"application/json; charset=utf-8",accept:"application/graphql+json, application/json"}),credentials:t,referrer:o,referrerPolicy:n,body:JSON.stringify(l)})}catch(e){throw new r(e)}if(!u.ok)throw new r(u);if(!u.body)throw new Error("Missing response body");const d=u.headers.get("content-type");if(!d)throw new Error("Missing response content-type");if(!d.includes("application/graphql+json")&&!d.includes("application/json"))throw new Error(`Unsupported response content-type ${d}`);const h=await u.json();return p.next(h),f.abort()}catch(e){if(f.signal.aborted)return;if(!(e instanceof r))throw e;c=e}}})().then((()=>p.complete())).catch((e=>p.error(e))),()=>f.abort()},dispose(){c.dispose()}}},e.isResponse=function(e){return Array.isArray(e)&&("string"==typeof e[0]||null===e[0])&&t(e[1])},Object.defineProperty(e,"__esModule",{value:!0})}));
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).graphqlHttp={})}(this,(function(e){"use strict";class t extends Error{constructor(e){let t,r;var o;(function(e){return"object"==typeof e&&null!==e})(o=e)&&"boolean"==typeof o.ok&&"number"==typeof o.status&&"string"==typeof o.statusText?(r=e,t="Server responded with "+e.status+": "+e.statusText):t=e instanceof Error?e.message:String(e),super(t),this.name=this.constructor.name,this.response=r}}e.NetworkError=t,e.createClient=function(e){const{credentials:r="same-origin",referrer:o,referrerPolicy:n,shouldRetry:s=(()=>!1)}=e,i=e.fetchFn||fetch,a=e.abortControllerImpl||AbortController,c=(()=>{let e=!1;const t=[];return{get disposed(){return e},onDispose:r=>e?(setTimeout((()=>r()),0),()=>{}):(t.push(r),()=>{t.splice(t.indexOf(r),1)}),dispose(){if(!e){e=!0;for(const e of[...t])e()}}}})();return{subscribe(p,l){if(c.disposed)throw new Error("Client has been disposed");const f=new a,u=c.onDispose((()=>{u(),f.abort()}));return(async()=>{var a;let c=null,u=0;for(;;){if(c){const e=await s(c,u);if(f.signal.aborted)return;if(!e)throw c;u++}try{const s="function"==typeof e.url?await e.url(p):e.url;if(f.signal.aborted)return;const c="function"==typeof e.headers?await e.headers():null!==(a=e.headers)&&void 0!==a?a:{};if(f.signal.aborted)return;let u;try{u=await i(s,{signal:f.signal,method:"POST",headers:Object.assign(Object.assign({},c),{"content-type":"application/json; charset=utf-8",accept:"application/graphql-response+json, application/json"}),credentials:r,referrer:o,referrerPolicy:n,body:JSON.stringify(p)})}catch(e){throw new t(e)}if(!u.ok)throw new t(u);if(!u.body)throw new Error("Missing response body");const d=u.headers.get("content-type");if(!d)throw new Error("Missing response content-type");if(!d.includes("application/graphql-response+json")&&!d.includes("application/json"))throw new Error(`Unsupported response content-type ${d}`);const h=await u.json();return l.next(h),f.abort()}catch(e){if(f.signal.aborted)return;if(!(e instanceof t))throw e;c=e}}})().then((()=>l.complete())).catch((e=>l.error(e))),()=>f.abort()},dispose(){c.dispose()}}},Object.defineProperty(e,"__esModule",{value:!0})}));