return (req, res, next): void => {
runHttpQuery([req, res], {
method: req.method,
options: options,
query: req.method === 'POST' ? req.body : req.query,
request: convertNodeHttpToRequest(req),
}).then(
({ graphqlResponse, responseInit }) => {
if (responseInit.headers) {
for (const [name, value] of Object.entries(responseInit.headers)) {
res.setHeader(name, value);
}
}
res.write(graphqlResponse);
res.end();
},
(error: HttpQueryError) => {
if ('HttpQueryError' !== error.name) {
return next(error);
}
if (error.headers) {
for (const [name, value] of Object.entries(error.headers)) {
res.setHeader(name, value);
}
}
res.statusCode = error.statusCode;
res.write(error.message);
res.end();
},
);
};
const graphqlHandler = async (req: Request): Promise<Response> => {
const url = new URL(req.url);
const query =
req.method === 'POST'
? await req.json()
: {
query: url.searchParams.get('query'),
variables: url.searchParams.get('variables'),
operationName: url.searchParams.get('operationName'),
extensions: url.searchParams.get('extensions'),
};
return runHttpQuery([req], {
method: req.method,
options: options,
query,
request: req as Request,
}).then(
({ graphqlResponse, responseInit }) =>
new Response(graphqlResponse, responseInit),
(error: HttpQueryError) => {
if ('HttpQueryError' !== error.name) throw error;
const res = new Response(error.message, {
status: error.statusCode,
headers: error.headers,
});
return res;
},
);
};
function runHttpQueryWrapper(options: GraphQLOptions | HapiOptionsFunction, request: Request, reply: ReplyNoContinue): Promise<Response> {
return runHttpQuery([request], {
method: request.method.toUpperCase(),
options: options,
query: request.method === 'post' ? request.payload : request.query,
}).then((gqlResponse) => {
return reply(gqlResponse).type('application/json');
}, (error: HttpQueryError) => {
if ( 'HttpQueryError' !== error.name ) {
throw error;
}
if ( true === error.isGraphQLError ) {
return reply(error.message).code(error.statusCode).type('application/json');
}
const err = Boom.create(error.statusCode);
err.output.payload.message = error.message;
if ( error.headers ) {
Object.keys(error.headers).forEach((header) => {
err.output.headers[header] = error.headers[header];
});
}
return reply(err);
});
}
handler: async (request, h) => {
try {
const gqlResponse = await runHttpQuery([request], {
method: request.method.toUpperCase(),
options: options.graphqlOptions,
query: request.method === 'post' ? request.payload : request.query,
});
const response = h.response(gqlResponse);
response.type('application/json');
return response;
} catch (error) {
if ('HttpQueryError' !== error.name) {
throw Boom.boomify(error);
}
if (true === error.isGraphQLError) {
const response = h.response(error.message);
response.code(error.statusCode);
response.type('application/json');
return response;
}
const err = new Boom(error.message, { statusCode: error.statusCode });
if (error.headers) {
Object.keys(error.headers).forEach(header => {
err.output.headers[header] = error.headers[header];
});
}
// Boom hides the error when status code is 500
err.output.payload.message = error.message;
throw err;
}
},
return (httpContext: IHttpContext, request: IFunctionRequest) => {
const queryRequest = {
method: request.method,
options: options,
query: request.method === 'POST' ? request.body : request.query,
};
if (queryRequest.query && typeof queryRequest.query === 'string') {
queryRequest.query = JSON.parse(queryRequest.query);
}
return runHttpQuery([httpContext, request], queryRequest)
.then(gqlResponse => {
const result = {
status: 200,
headers: { 'Content-Type': 'application/json' },
body: gqlResponse,
};
httpContext.res = result;
httpContext.done(null, result);
})
.catch(error => {
const result = {
status: error.statusCode,
headers: error.headers,
body: error.message,
};
httpContext.res = result;
httpContext.done(null, result);
});
};
handler: async (request: Request, h: ResponseToolkit) => {
try {
const { method } = request;
const query =
method === 'post'
? (request.payload as Record<string, any>)
: (request.query as Record<string, any>);
const graphQLResponse = await runHttpQuery([request], {
method: method.toUpperCase(),
options: options.graphQLOptions,
query,
});
return h.response(graphQLResponse).type('application/json');
} catch (error) {
if (error.isGraphQLError === true) {
return h
.response(error.message)
.code(error.statusCode)
.type('application/json');
}
return h.response(error).type('application/json');
}
},
const graphqlHandler = (
req: restify.Request,
res: restify.Response,
next: restify.Next,
): void => {
runHttpQuery([req, res], {
method: req.method,
options: options,
query: req.method === 'POST' ? req.body : req.query,
}).then(
gqlResponse => {
res.setHeader('Content-Type', 'application/json');
res.write(gqlResponse);
res.end();
next();
},
(error: HttpQueryError) => {
if ('HttpQueryError' !== error.name) {
throw error;
}
if (error.headers) {
Object.keys(error.headers).forEach(header => {
res.setHeader(header, error.headers[header]);
});
}
res.statusCode = error.statusCode;
res.write(error.message);
res.end();
next(false);
},
);
};
const graphqlHandler = async (req: MicroRequest, res: ServerResponse) => {
let query;
try {
query =
req.method === 'POST'
? req.filePayload || (await json(req))
: url.parse(req.url, true).query;
} catch (error) {
// Do nothing; `query` stays `undefined`
}
try {
const { graphqlResponse, responseInit } = await runHttpQuery([req, res], {
method: req.method,
options,
query,
request: convertNodeHttpToRequest(req),
});
setHeaders(res, responseInit.headers);
return graphqlResponse;
} catch (error) {
if ('HttpQueryError' === error.name && error.headers) {
setHeaders(res, error.headers);
}
if (!error.statusCode) {
error.statusCode = 500;
}
throw error;
}
};
const graphqlHandler = (
req: express.Request,
res: express.Response,
next,
): void => {
runHttpQuery([req, res], {
method: req.method,
options: options,
query: req.method === 'POST' ? req.body : req.query,
request: convertNodeHttpToRequest(req),
}).then(
({ graphqlResponse, responseInit }) => {
Object.keys(responseInit.headers).forEach(key =>
res.setHeader(key, responseInit.headers[key]),
);
res.write(graphqlResponse);
res.end();
},
(error: HttpQueryError) => {
if ('HttpQueryError' !== error.name) {
return next(error);
}
if (error.headers) {
Object.keys(error.headers).forEach(header => {
res.setHeader(header, error.headers[header]);
});
}
res.statusCode = error.statusCode;
res.write(error.message);
res.end();
},
);
};
const graphqlHandler = (ctx: Koa.Context): Promise<void> => {
return runHttpQuery([ctx], {
method: ctx.request.method,
options: options,
query:
ctx.request.method === 'POST'
? // fallback to ctx.req.body for koa-multer support
ctx.request.body || (ctx.req as any).body
: ctx.request.query,
request: convertNodeHttpToRequest(ctx.req),
}).then(
({ graphqlResponse, responseInit }) => {
Object.keys(responseInit.headers).forEach(key =>
ctx.set(key, responseInit.headers[key]),
);
ctx.body = graphqlResponse;
},
(error: HttpQueryError) => {
if ('HttpQueryError' !== error.name) {
throw error;
}
if (error.headers) {
Object.keys(error.headers).forEach(header => {
ctx.set(header, error.headers[header]);
});
}
ctx.status = error.statusCode;
ctx.body = error.message;
},
);
};
