Your IP : 216.73.217.13
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getGraphQLParams = exports.graphqlHTTP = void 0;
const accepts_1 = __importDefault(require("accepts"));
const http_errors_1 = __importDefault(require("http-errors"));
const graphql_1 = require("graphql");
const parseBody_1 = require("./parseBody");
const renderGraphiQL_1 = require("./renderGraphiQL");
/**
* Middleware for express; takes an options object or function as input to
* configure behavior, and returns an express middleware.
*/
function graphqlHTTP(options) {
devAssert(options != null, 'GraphQL middleware requires options.');
return async function graphqlMiddleware(request, response) {
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
// Higher scoped variables are referred to at various stages in the asynchronous state machine below.
let params;
let showGraphiQL = false;
let graphiqlOptions;
let formatErrorFn = graphql_1.formatError;
let pretty = false;
let result;
try {
// Parse the Request to get GraphQL request parameters.
try {
params = await getGraphQLParams(request);
}
catch (error) {
// When we failed to parse the GraphQL parameters, we still need to get
// the options object, so make an options call to resolve just that.
const optionsData = await resolveOptions();
pretty = (_a = optionsData.pretty) !== null && _a !== void 0 ? _a : false;
formatErrorFn = (_c = (_b = optionsData.customFormatErrorFn) !== null && _b !== void 0 ? _b : optionsData.formatError) !== null && _c !== void 0 ? _c : formatErrorFn;
throw error;
}
// Then, resolve the Options to get OptionsData.
const optionsData = await resolveOptions(params);
// Collect information from the options data object.
const schema = optionsData.schema;
const rootValue = optionsData.rootValue;
const validationRules = (_d = optionsData.validationRules) !== null && _d !== void 0 ? _d : [];
const fieldResolver = optionsData.fieldResolver;
const typeResolver = optionsData.typeResolver;
const graphiql = (_e = optionsData.graphiql) !== null && _e !== void 0 ? _e : false;
const extensionsFn = optionsData.extensions;
const context = (_f = optionsData.context) !== null && _f !== void 0 ? _f : request;
const parseFn = (_g = optionsData.customParseFn) !== null && _g !== void 0 ? _g : graphql_1.parse;
const executeFn = (_h = optionsData.customExecuteFn) !== null && _h !== void 0 ? _h : graphql_1.execute;
const validateFn = (_j = optionsData.customValidateFn) !== null && _j !== void 0 ? _j : graphql_1.validate;
pretty = (_k = optionsData.pretty) !== null && _k !== void 0 ? _k : false;
formatErrorFn = (_m = (_l = optionsData.customFormatErrorFn) !== null && _l !== void 0 ? _l : optionsData.formatError) !== null && _m !== void 0 ? _m : formatErrorFn;
// Assert that schema is required.
devAssert(schema != null, 'GraphQL middleware options must contain a schema.');
// GraphQL HTTP only supports GET and POST methods.
if (request.method !== 'GET' && request.method !== 'POST') {
throw http_errors_1.default(405, 'GraphQL only supports GET and POST requests.', {
headers: { Allow: 'GET, POST' },
});
}
// Get GraphQL params from the request and POST body data.
const { query, variables, operationName } = params;
showGraphiQL = canDisplayGraphiQL(request, params) && graphiql !== false;
if (typeof graphiql !== 'boolean') {
graphiqlOptions = graphiql;
}
// If there is no query, but GraphiQL will be displayed, do not produce
// a result, otherwise return a 400: Bad Request.
if (query == null) {
if (showGraphiQL) {
return respondWithGraphiQL(response, graphiqlOptions);
}
throw http_errors_1.default(400, 'Must provide query string.');
}
// Validate Schema
const schemaValidationErrors = graphql_1.validateSchema(schema);
if (schemaValidationErrors.length > 0) {
// Return 500: Internal Server Error if invalid schema.
throw http_errors_1.default(500, 'GraphQL schema validation error.', {
graphqlErrors: schemaValidationErrors,
});
}
// Parse source to AST, reporting any syntax error.
let documentAST;
try {
documentAST = parseFn(new graphql_1.Source(query, 'GraphQL request'));
}
catch (syntaxError) {
// Return 400: Bad Request if any syntax errors errors exist.
throw http_errors_1.default(400, 'GraphQL syntax error.', {
graphqlErrors: [syntaxError],
});
}
// Validate AST, reporting any errors.
const validationErrors = validateFn(schema, documentAST, [
...graphql_1.specifiedRules,
...validationRules,
]);
if (validationErrors.length > 0) {
// Return 400: Bad Request if any validation errors exist.
throw http_errors_1.default(400, 'GraphQL validation error.', {
graphqlErrors: validationErrors,
});
}
// Only query operations are allowed on GET requests.
if (request.method === 'GET') {
// Determine if this GET request will perform a non-query.
const operationAST = graphql_1.getOperationAST(documentAST, operationName);
if (operationAST && operationAST.operation !== 'query') {
// If GraphiQL can be shown, do not perform this query, but
// provide it to GraphiQL so that the requester may perform it
// themselves if desired.
if (showGraphiQL) {
return respondWithGraphiQL(response, graphiqlOptions, params);
}
// Otherwise, report a 405: Method Not Allowed error.
throw http_errors_1.default(405, `Can only perform a ${operationAST.operation} operation from a POST request.`, { headers: { Allow: 'POST' } });
}
}
// Perform the execution, reporting any errors creating the context.
try {
result = await executeFn({
schema,
document: documentAST,
rootValue,
contextValue: context,
variableValues: variables,
operationName,
fieldResolver,
typeResolver,
});
}
catch (contextError) {
// Return 400: Bad Request if any execution context errors exist.
throw http_errors_1.default(400, 'GraphQL execution context error.', {
graphqlErrors: [contextError],
});
}
// Collect and apply any metadata extensions if a function was provided.
// https://graphql.github.io/graphql-spec/#sec-Response-Format
if (extensionsFn) {
const extensions = await extensionsFn({
document: documentAST,
variables,
operationName,
result,
context,
});
if (extensions != null) {
result = { ...result, extensions };
}
}
}
catch (rawError) {
// If an error was caught, report the httpError status, or 500.
const error = http_errors_1.default(500,
/* istanbul ignore next: Thrown by underlying library. */
rawError instanceof Error ? rawError : String(rawError));
response.statusCode = error.status;
const { headers } = error;
if (headers != null) {
for (const [key, value] of Object.entries(headers)) {
response.setHeader(key, String(value));
}
}
if (error.graphqlErrors == null) {
const graphqlError = new graphql_1.GraphQLError(error.message, undefined, undefined, undefined, undefined, error);
result = { data: undefined, errors: [graphqlError] };
}
else {
result = { data: undefined, errors: error.graphqlErrors };
}
}
// If no data was included in the result, that indicates a runtime query
// error, indicate as such with a generic status code.
// Note: Information about the error itself will still be contained in
// the resulting JSON payload.
// https://graphql.github.io/graphql-spec/#sec-Data
if (response.statusCode === 200 && result.data == null) {
response.statusCode = 500;
}
// Format any encountered errors.
const formattedResult = {
...result,
errors: (_o = result.errors) === null || _o === void 0 ? void 0 : _o.map(formatErrorFn),
};
// If allowed to show GraphiQL, present it instead of JSON.
if (showGraphiQL) {
return respondWithGraphiQL(response, graphiqlOptions, params, formattedResult);
}
// If "pretty" JSON isn't requested, and the server provides a
// response.json method (express), use that directly.
// Otherwise use the simplified sendResponse method.
if (!pretty && typeof response.json === 'function') {
response.json(formattedResult);
}
else {
const payload = JSON.stringify(formattedResult, null, pretty ? 2 : 0);
sendResponse(response, 'application/json', payload);
}
async function resolveOptions(requestParams) {
const optionsResult = await Promise.resolve(typeof options === 'function'
? options(request, response, requestParams)
: options);
devAssert(optionsResult != null && typeof optionsResult === 'object', 'GraphQL middleware option function must return an options object or a promise which will be resolved to an options object.');
if (optionsResult.formatError) {
// eslint-disable-next-line no-console
console.warn('`formatError` is deprecated and replaced by `customFormatErrorFn`. It will be removed in version 1.0.0.');
}
return optionsResult;
}
};
}
exports.graphqlHTTP = graphqlHTTP;
function respondWithGraphiQL(response, options, params, result) {
const data = {
query: params === null || params === void 0 ? void 0 : params.query,
variables: params === null || params === void 0 ? void 0 : params.variables,
operationName: params === null || params === void 0 ? void 0 : params.operationName,
result,
};
const payload = renderGraphiQL_1.renderGraphiQL(data, options);
return sendResponse(response, 'text/html', payload);
}
/**
* Provided a "Request" provided by express or connect (typically a node style
* HTTPClientRequest), Promise the GraphQL request parameters.
*/
async function getGraphQLParams(request) {
var _a, _b, _c;
const urlData = new URLSearchParams(request.url.split('?')[1]);
const bodyData = await parseBody_1.parseBody(request);
// GraphQL Query string.
let query = (_a = urlData.get('query')) !== null && _a !== void 0 ? _a : bodyData.query;
if (typeof query !== 'string') {
query = null;
}
// Parse the variables if needed.
let variables = ((_b = urlData.get('variables')) !== null && _b !== void 0 ? _b : bodyData.variables);
if (typeof variables === 'string') {
try {
variables = JSON.parse(variables);
}
catch (_d) {
throw http_errors_1.default(400, 'Variables are invalid JSON.');
}
}
else if (typeof variables !== 'object') {
variables = null;
}
// Name of GraphQL operation to execute.
let operationName = (_c = urlData.get('operationName')) !== null && _c !== void 0 ? _c : bodyData.operationName;
if (typeof operationName !== 'string') {
operationName = null;
}
const raw = urlData.get('raw') != null || bodyData.raw !== undefined;
return { query, variables, operationName, raw };
}
exports.getGraphQLParams = getGraphQLParams;
/**
* Helper function to determine if GraphiQL can be displayed.
*/
function canDisplayGraphiQL(request, params) {
// If `raw` false, GraphiQL mode is not enabled.
// Allowed to show GraphiQL if not requested as raw and this request prefers HTML over JSON.
return !params.raw && accepts_1.default(request).types(['json', 'html']) === 'html';
}
/**
* Helper function for sending a response using only the core Node server APIs.
*/
function sendResponse(response, type, data) {
const chunk = Buffer.from(data, 'utf8');
response.setHeader('Content-Type', type + '; charset=utf-8');
response.setHeader('Content-Length', String(chunk.length));
response.end(chunk);
}
function devAssert(condition, message) {
const booleanCondition = Boolean(condition);
if (!booleanCondition) {
throw new Error(message);
}
}