graphql-http 0.2.0 → 1.0.0

package/lib/handler.mjs

@@ -0,0 +1,310 @@
+/**
+ *
+ * handler
+ *
+ */
+import { validate as graphqlValidate, execute as graphqlExecute, parse, getOperationAST, } from 'graphql';
+import { isResponse } from './common.mjs';
+/**
+ * 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, 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',
+                    },
+                },
+            ];
+        }
+        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;
+            }
+        }
+        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 url = new URL(req.url || '', 'http://localhost/');
+                        partParams.operationName =
+                            (_a = url.searchParams.get('operationName')) !== null && _a !== void 0 ? _a : undefined;
+                        partParams.query = (_b = url.searchParams.get('query')) !== null && _b !== void 0 ? _b : undefined;
+                        const variables = url.searchParams.get('variables');
+                        if (variables)
+                            partParams.variables = JSON.parse(variables);
+                        const extensions = url.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)
+                throw new Error('Missing 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 [
+                err.message,
+                {
+                    status: acceptedMediaType === 'application/json' ? 200 : 400,
+                    statusText: 'Bad Request',
+                },
+            ];
+        }
+        let args;
+        const maybeResOrExecArgs = await (onSubscribe === null || onSubscribe === void 0 ? void 0 : onSubscribe(req, params));
+        if (isResponse(maybeResOrExecArgs))
+            return maybeResOrExecArgs;
+        else if (maybeResOrExecArgs)
+            args = maybeResOrExecArgs;
+        else {
+            if (!schema)
+                throw new Error('The GraphQL schema is not provided');
+            const { operationName, query, variables } = params;
+            let document;
+            try {
+                document = parse(query);
+            }
+            catch (_e) {
+                return [
+                    'GraphQL query syntax error',
+                    {
+                        status: acceptedMediaType === 'application/json' ? 200 : 400,
+                        statusText: 'Bad Request',
+                    },
+                ];
+            }
+            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 });
+            }
+        }
+        let operation;
+        try {
+            const ast = getOperationAST(args.document, args.operationName);
+            if (!ast)
+                throw null;
+            operation = ast.operation;
+        }
+        catch (_f) {
+            return [
+                'Unable to detect operation AST',
+                {
+                    status: acceptedMediaType === 'application/json' ? 200 : 400,
+                    statusText: 'Bad Request',
+                },
+            ];
+        }
+        if (operation === 'subscription') {
+            return [
+                'Subscriptions are not supported',
+                {
+                    status: 400,
+                    statusText: 'Bad Request',
+                },
+            ];
+        }
+        // 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',
+                {
+                    status: 405,
+                    statusText: 'Method Not Allowed',
+                    headers: {
+                        allow: 'POST',
+                    },
+                },
+            ];
+        }
+        if (!('contextValue' in args)) {
+            args.contextValue =
+                typeof context === 'function' ? await context(req, args) : context;
+        }
+        const validationErrs = validate(args.schema, args.document);
+        if (validationErrs.length) {
+            return [
+                JSON.stringify({ errors: validationErrs }),
+                {
+                    status: acceptedMediaType === 'application/json' ? 200 : 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;
+        return [
+            JSON.stringify(result),
+            {
+                status: 200,
+                statusText: 'OK',
+                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,7 @@
+/**
+ *
+ * utils
+ *
+ */
+/** @private */
+export declare function isObject(val: unknown): val is Record<PropertyKey, unknown>;

package/lib/utils.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ *
+ * utils
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = void 0;
+/** @private */
+function isObject(val) {
+    return typeof val === 'object' && val !== null;
+}
+exports.isObject = isObject;

package/lib/utils.mjs

@@ -0,0 +1,9 @@
+/**
+ *
+ * utils
+ *
+ */
+/** @private */
+export function isObject(val) {
+    return typeof val === 'object' && val !== null;
+}

package/package.json

@@ -1,37 +1,99 @@
 {
   "name": "graphql-http",
-  "version": "0.2.0",
-  "description": "A GraphQL client for executing GraphQL queries over HTTP.",
-  "scripts": {
-    "test": "eslint lib && jest"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/petermelias/graphql-http.git"
-  },
+  "version": "1.0.0",
+  "description": "Simple, plugable, zero-dependency, GraphQL over HTTP Protocol compliant server and client",
   "keywords": [
     "graphql",
+    "client",
+    "relay",
+    "express",
+    "apollo",
+    "server",
     "http",
-    "xhr",
-    "graphql-client",
-    "axios",
-    "fetch"
+    "transport",
+    "observables",
+    "fastify"
   ],
-  "author": "Peter M. Elias",
+  "author": "Denis Badurina <badurinadenis@gmail.com>",
   "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/petermelias/graphql-http/issues"
+  "homepage": "https://github.com/enisdenjo/graphql-http#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/enisdenjo/graphql-http.git"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "packageManager": "yarn@3.2.2",
+  "main": "lib/index.js",
+  "module": "lib/index.mjs",
+  "browser": "umd/graphql-http.js",
+  "exports": {
+    ".": {
+      "require": "./lib/index.js",
+      "import": "./lib/index.mjs",
+      "types": "./lib/index.d.ts",
+      "browser": "./umd/graphql-http.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "umd",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "sideEffects": [
+    "umd/*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "gendocs": "typedoc --options typedoc.js src/",
+    "lint": "eslint 'src'",
+    "type-check": "tsc --noEmit",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "build:esm": "tsc -b tsconfig.esm.json && node scripts/esm-post-process.js",
+    "build:cjs": "tsc -b tsconfig.cjs.json",
+    "build:umd": "rollup -c && gzip umd/graphql-http.min.js -c > umd/graphql-http.min.js.gz",
+    "build": "yarn build:esm && yarn build:cjs && yarn build:umd",
+    "release": "semantic-release"
   },
-  "homepage": "https://github.com/petermelias/graphql-http#readme",
-  "dependencies": {
-    "isomorphic-fetch": "^2.2.1",
-    "lodash.merge": "^4.0.0"
+  "peerDependencies": {
+    "graphql": ">=0.11 <=16"
   },
-  "peerDependencies": {},
   "devDependencies": {
-    "eslint": "^3.9.0",
-    "eslint-config-semistandard": "^7.0.0",
-    "fetch-mock": "^5.5.0",
-    "jest": "^16.0.2"
+    "@babel/core": "^7.18.10",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.18.6",
+    "@babel/plugin-proposal-object-rest-spread": "^7.18.9",
+    "@babel/plugin-proposal-optional-chaining": "^7.18.9",
+    "@babel/preset-env": "^7.18.10",
+    "@babel/preset-typescript": "^7.18.6",
+    "@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",
+    "babel-jest": "^28.1.3",
+    "eslint": "^8.21.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "graphql": "^16.5.0",
+    "jest": "^28.1.3",
+    "jest-jasmine2": "^28.1.3",
+    "node-fetch": "^3.2.10",
+    "prettier": "^2.7.1",
+    "replacestream": "^4.0.3",
+    "rollup": "^2.77.2",
+    "rollup-plugin-terser": "^7.0.2",
+    "semantic-release": "^19.0.3",
+    "tslib": "^2.4.0",
+    "typedoc": "^0.23.10",
+    "typedoc-plugin-markdown": "^3.13.4",
+    "typescript": "^4.7.4"
   }
 }