graphql-http 0.2.0 → 1.2.0

package/lib/handler.mjs

@@ -0,0 +1,346 @@
+/**
+ *
+ * handler
+ *
+ */
+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.
+ *
+ * Beware that the handler resolves only after the whole operation completes.
+ *
+ * Errors thrown from **any** of the provided options or callbacks (or even due to
+ * library misuse or potential bugs) will reject the handler's promise. They are
+ * considered internal errors and you should take care of them accordingly.
+ *
+ * For production environments, its recommended not to transmit the exact internal
+ * error details to the client, but instead report to an error logging tool or simply
+ * the console.
+ *
+ * Simple example usage with Node:
+ *
+ * ```js
+ * import http from 'http';
+ * import { createHandler } from 'graphql-http';
+ * import { schema } from './my-graphql-schema.mjs';
+ *
+ * // Create the GraphQL over HTTP handler
+ * const handler = createHandler({ schema });
+ *
+ * // Create a HTTP server using the handler on `/graphql`
+ * const server = http.createServer(async (req, res) => {
+ *   if (!req.url.startsWith('/graphql')) {
+ *     return res.writeHead(404).end();
+ *   }
+ *
+ *   try {
+ *     const [body, init] = await handler({
+ *       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));
+ *       }),
+ *       raw: req,
+ *     });
+ *     res.writeHead(init.status, init.statusText, init.headers).end(body);
+ *   } catch (err) {
+ *     // BEWARE not to transmit the exact internal error message in production environments
+ *     res.writeHead(500).end(err.message);
+ *   }
+ * });
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server
+ */
+export function createHandler(options) {
+    const { schema, context, validate = graphqlValidate, execute = graphqlExecute, parse = graphqlParse, getOperationAST = graphqlGetOperationAST, onSubscribe, onOperation, } = 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',
+                    },
+                },
+            ];
+        }
+        const acceptedMediaType = getAcceptableMediaType(req.headers.accept);
+        if (!acceptedMediaType) {
+            return [
+                null,
+                {
+                    status: 406,
+                    statusText: 'Not Acceptable',
+                    headers: {
+                        accept: 'application/graphql+json; charset=utf-8, application/json; charset=utf-8',
+                    },
+                },
+            ];
+        }
+        // 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'] || '')
+            .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');
+                        }
+                        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;
+                        }
+                        catch (_d) {
+                            throw new Error('Unparsable JSON body');
+                        }
+                        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.extensions != null &&
+                (typeof partParams.extensions !== 'object' ||
+                    Array.isArray(partParams.extensions))) {
+                throw new Error('Invalid extensions');
+            }
+            // request parameters are checked and now complete
+            params = partParams;
+        }
+        catch (err) {
+            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 (isExecutionResult(maybeResErrsOrArgs) ||
+            areGraphQLErrors(maybeResErrsOrArgs))
+            return makeResponse(maybeResErrsOrArgs, acceptedMediaType);
+        else if (maybeResErrsOrArgs)
+            args = maybeResErrsOrArgs;
+        else {
+            if (!schema)
+                throw new Error('The GraphQL schema is not provided');
+            const { operationName, query, variables } = params;
+            let document;
+            try {
+                document = parse(query);
+            }
+            catch (err) {
+                return makeResponse(err, acceptedMediaType);
+            }
+            const argsWithoutSchema = {
+                operationName,
+                document,
+                variableValues: variables,
+            };
+            if (typeof schema === 'function') {
+                const resOrSchema = await schema(req, argsWithoutSchema);
+                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 {
+            const ast = getOperationAST(args.document, args.operationName);
+            if (!ast)
+                throw null;
+            operation = ast.operation;
+        }
+        catch (_e) {
+            return makeResponse(new GraphQLError('Unable to detect operation AST'), acceptedMediaType);
+        }
+        if (operation === 'subscription') {
+            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 [
+                JSON.stringify({
+                    errors: [new GraphQLError('Cannot perform mutations over GET')],
+                }),
+                {
+                    status: 405,
+                    statusText: 'Method Not Allowed',
+                    headers: {
+                        allow: 'POST',
+                    },
+                },
+            ];
+        }
+        if (!('contextValue' in args)) {
+            const maybeResOrContext = typeof context === 'function' ? await context(req, args) : context;
+            if (isResponse(maybeResOrContext))
+                return maybeResOrContext;
+            args.contextValue = maybeResOrContext;
+        }
+        let result = await execute(args);
+        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+json' ||
+            mediaType === 'application/*' ||
+            mediaType === '*/*') &&
+            charset === 'charset=utf8') {
+            acceptedMediaType = 'application/graphql+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(resultOrErrors),
+            {
+                status: 200,
+                statusText: 'OK',
+                headers: {
+                    'content-type': acceptedMediaType === 'application/json'
+                        ? 'application/json; charset=utf-8'
+                        : 'application/graphql+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+json; charset=utf-8',
+            } }),
+    ];
+}

package/lib/index.d.ts

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

package/lib/index.js

@@ -1,189 +1,19 @@
-'use strict';
-
-var merge = require('lodash.merge');
-var url = require('url');
-var qs = require('querystring');
-
-require('isomorphic-fetch');
-
-function GQLClient (url, options) {
-  if (!(this instanceof GQLClient)) {
-    return new GQLClient(url, options);
-  }
-
-  if (options == null) {
-    options = {};
-  }
-
-  if (url == null) {
-    throw new TypeError('GQLClient must have a url');
-  }
-
-  this.url = url;
-  this.options = Object.assign({method: 'get'}, options);
-}
-
-GQLClient.prototype.configure = function (options) {
-  return new GQLClient(this.url, merge({}, this.options, options));
-};
-
-GQLClient.prototype.query = function (query, variables) {
-  if (query == null) {
-    throw new TypeError('got ' + query + ' for GQLClient#query query');
-  }
-
-  if (variables == null) {
-    variables = {};
-  }
-
-  var params = qs.stringify({
-    query: query,
-    variables: JSON.stringify(variables)
-  });
-
-  var requestUrl = this.options.onlyBody ? (
-    this.url
-  ) : (
-    this.url + '?' + params
-  );
-
-  var method = this.options.method.toLowerCase();
-
-  if (method === 'get') {
-    var fetchOptions = this.options.fetch;
-  } else if (method === 'post') {
-    var fetchOptions = merge({
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json'
-      },
-      body: JSON.stringify({query: query, variables: variables})
-    }, this.options.fetch);
-  } else {
-    throw new TypeError('Unknown value "' + method + '" for method parameter');
-  }
-
-  return fetch(requestUrl, fetchOptions)
-    .then(handleResponse);
-};
-
-GQLClient.prototype.mutate = function (query, variables) {
-  if (this.options.method.toLowerCase() !== 'post') {
-    return this.configure({method: 'post'}).query(query, variables);
-  } else {
-    return this.query(query, variables);
-  }
-};
-
-exports.GQLClient = GQLClient;
-
-function handleResponse (resp) {
-  if (resp.ok) {
-    return handleOkayResponse(resp);
-  } else if (/json/.test(resp.headers.get('Content-Type'))) {
-    return handleJSONErrorResponse(resp);
-  } else {
-    return handleUnknownErrorResponse(resp);
-  }
-}
-
-function handleOkayResponse (resp) {
-  return resp.json().then(function (body) {
-    if (body == null) {
-      throw formatErrors(
-        'Missing/null body response from GraphQL.',
-        body
-      );
-    } else if (body.errors instanceof Array && body.errors.length > 0) {
-      throw formatErrors(
-        'Received ' + body.errors.length + ' error(s) from GraphQL.',
-        body
-      );
-    } else {
-      return body;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-  });
-}
-
-function formatErrors (message, body) {
-  if (body != null && body.errors instanceof Array) {
-    var errorMessages = body.errors.map(errorToMessage);
-
-    return new GraphQLResponseError(
-      [message].concat(errorMessages).join('\n')
-    );
-  } else {
-    return new GraphQLResponseError(
-      [
-        message,
-        'Unrecognized body structure "' + JSON.stringify(body) + '"'
-      ].join('\n')
-    );
-  }
-}
-
-function handleJSONErrorResponse (resp, body) {
-  return resp.json().then(function (body) {
-    var message = 'Received status ' + resp.status + ' from GraphQL.';
-
-    throw formatErrors(message, body);
-  });
-}
-
-function errorToMessage (error) {
-  if (error != null && error.message != null) {
-    return error.message;
-  } else {
-    return JSON.stringify(error);
-  }
-}
-
-function handleUnknownErrorResponse (resp) {
-  var message = 'Received status ' + resp.status + ' from GraphQL.';
-
-  throw formatErrors(message, {
-    errors: [{
-      message: 'Unknown content type "' + resp.headers.get('Content-Type') + '".'
-    }]
-  });
-}
-
-function GraphQLError (message) {
-  this.message = message;
-
-  if (message instanceof Error) {
-    this.message = message.message;
-    this.stack = message.stack;
-  } else if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, GraphQLError);
-  }
-}
-
-GraphQLError.prototype = Object.create(Error.prototype);
-GraphQLError.prototype.constructor = GraphQLError;
-
-Object.defineProperty(GraphQLError.prototype, 'name', {
-  value: 'GraphQLError'
-});
-
-exports.GraphQLError = GraphQLError;
-
-function GraphQLResponseError (message) {
-  this.message = message;
-
-  if (message instanceof Error) {
-    this.message = message.message;
-    this.stack = message.stack;
-  } else if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, GraphQLResponseError);
-  }
-}
-
-GraphQLResponseError.prototype = Object.create(GraphQLError.prototype);
-GraphQLResponseError.prototype.constructor = GraphQLResponseError;
-
-Object.defineProperty(GraphQLResponseError.prototype, 'name', {
-  value: 'GraphQLResponseError'
-});
-
-exports.GraphQLResponseError = GraphQLResponseError;
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common"), exports);
+__exportStar(require("./handler"), exports);
+__exportStar(require("./client"), exports);

package/lib/index.mjs

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

package/lib/utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ *
+ * utils
+ *
+ */
+import type { ExecutionResult, GraphQLError } from 'graphql';
+/** @private */
+export declare function isObject(val: unknown): val is Record<PropertyKey, unknown>;
+/** @private */
+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

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ *
+ * utils
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAsyncIterable = exports.isExecutionResult = exports.areGraphQLErrors = exports.isObject = void 0;
+/** @private */
+function isObject(val) {
+    return typeof val === 'object' && val !== null;
+}
+exports.isObject = isObject;
+/** @private */
+function areGraphQLErrors(obj) {
+    return (Array.isArray(obj) &&
+        // must be at least one error
+        obj.length > 0 &&
+        // error has at least a message
+        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

@@ -0,0 +1,26 @@
+/**
+ *
+ * utils
+ *
+ */
+/** @private */
+export function isObject(val) {
+    return typeof val === 'object' && val !== null;
+}
+/** @private */
+export function areGraphQLErrors(obj) {
+    return (Array.isArray(obj) &&
+        // must be at least one error
+        obj.length > 0 &&
+        // 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';
+}