0
0
mirror of https://github.com/honojs/hono.git synced 2024-12-01 10:51:01 +00:00
hono/deno_dist/middleware/graphql-server/index.ts

239 lines
6.4 KiB
TypeScript
Raw Normal View History

2022-07-02 06:09:45 +00:00
// Based on the code in the `express-graphql` package.
// https://github.com/graphql/express-graphql/blob/main/src/index.ts
import {
Source,
parse,
execute,
validateSchema,
validate,
specifiedRules,
getOperationAST,
GraphQLError,
} from 'https://cdn.skypack.dev/graphql@16.4.0?dts'
import type {
GraphQLSchema,
DocumentNode,
ValidationRule,
FormattedExecutionResult,
GraphQLFormattedError,
} from 'https://cdn.skypack.dev/graphql@16.4.0?dts'
import type { Context } from '../../context.ts'
import type { Next } from '../../hono.ts'
import { parseBody } from './parse-body.ts'
type Options = {
schema: GraphQLSchema
rootValue?: unknown
pretty?: boolean
validationRules?: ReadonlyArray<ValidationRule>
// graphiql?: boolean
}
export const graphqlServer = (options: Options) => {
const schema = options.schema
const rootValue = options.rootValue
const pretty = options.pretty ?? false
const validationRules = options.validationRules ?? []
// const showGraphiQL = options.graphiql ?? false
return async (c: Context, next: Next) => {
// GraphQL HTTP only supports GET and POST methods.
if (c.req.method !== 'GET' && c.req.method !== 'POST') {
return c.json(errorMessages(['GraphQL only supports GET and POST requests.']), 405, {
Allow: 'GET, POST',
})
}
let params: GraphQLParams
try {
params = await getGraphQLParams(c.req)
} catch (e) {
if (e instanceof Error) {
console.error(`${e.stack || e.message}`)
return c.json(errorMessages([e.message], [e]), 400)
}
throw e
}
const { query, variables, operationName } = params
if (query == null) {
return c.json(errorMessages(['Must provide query string.']), 400)
}
const schemaValidationErrors = validateSchema(schema)
if (schemaValidationErrors.length > 0) {
// Return 500: Internal Server Error if invalid schema.
return c.json(
errorMessages(['GraphQL schema validation error.'], schemaValidationErrors),
500
)
}
let documentAST: DocumentNode
try {
documentAST = parse(new Source(query, 'GraphQL request'))
} catch (syntaxError: unknown) {
// Return 400: Bad Request if any syntax errors errors exist.
if (syntaxError instanceof Error) {
console.error(`${syntaxError.stack || syntaxError.message}`)
const e = new GraphQLError(syntaxError.message, {
originalError: syntaxError,
})
return c.json(errorMessages(['GraphQL syntax error.'], [e]), 400)
}
throw syntaxError
}
// Validate AST, reporting any errors.
const validationErrors = validate(schema, documentAST, [...specifiedRules, ...validationRules])
if (validationErrors.length > 0) {
// Return 400: Bad Request if any validation errors exist.
return c.json(errorMessages(['GraphQL validation error.'], validationErrors), 400)
}
if (c.req.method === 'GET') {
// Determine if this GET request will perform a non-query.
const operationAST = getOperationAST(documentAST, operationName)
if (operationAST && operationAST.operation !== 'query') {
/*
Now , does not support GraphiQL
if (showGraphiQL) {
//return respondWithGraphiQL(response, graphiqlOptions, params)
}
*/
// Otherwise, report a 405: Method Not Allowed error.
return c.json(
errorMessages([
`Can only perform a ${operationAST.operation} operation from a POST request.`,
]),
405,
{ Allow: 'POST' }
)
}
}
let result: FormattedExecutionResult
try {
result = await execute({
schema,
document: documentAST,
rootValue,
variableValues: variables,
operationName: operationName,
})
} catch (contextError: unknown) {
if (contextError instanceof Error) {
console.error(`${contextError.stack || contextError.message}`)
const e = new GraphQLError(contextError.message, {
originalError: contextError,
nodes: documentAST,
})
// Return 400: Bad Request if any execution context errors exist.
return c.json(errorMessages(['GraphQL execution context error.'], [e]), 400)
}
throw contextError
}
if (!result.data) {
if (result.errors) {
return c.json(errorMessages([result.errors.toString()], result.errors), 500)
}
}
/*
Now, does not support GraphiQL
if (showGraphiQL) {
}
*/
if (pretty) {
const payload = JSON.stringify(result, null, pretty ? 2 : 0)
return c.text(payload, 200, {
'Content-Type': 'application/json',
})
} else {
return c.json(result)
}
await next() // XXX
}
}
export interface GraphQLParams {
query: string | null
variables: { readonly [name: string]: unknown } | null
operationName: string | null
raw: boolean
}
export const getGraphQLParams = async (request: Request): Promise<GraphQLParams> => {
const urlData = new URLSearchParams(request.url.split('?')[1])
const bodyData = await parseBody(request)
// GraphQL Query string.
let query = urlData.get('query') ?? (bodyData.query as string | null)
if (typeof query !== 'string') {
query = null
}
// Parse the variables if needed.
let variables = (urlData.get('variables') ?? bodyData.variables) as {
readonly [name: string]: unknown
} | null
if (typeof variables === 'string') {
try {
variables = JSON.parse(variables)
} catch {
throw Error('Variables are invalid JSON.')
}
} else if (typeof variables !== 'object') {
variables = null
}
// Name of GraphQL operation to execute.
let operationName = urlData.get('operationName') ?? (bodyData.operationName as string | null)
if (typeof operationName !== 'string') {
operationName = null
}
const raw = urlData.get('raw') != null || bodyData.raw !== undefined
const params: GraphQLParams = {
query: query,
variables: variables,
operationName: operationName,
raw: raw,
}
return params
}
export const errorMessages = (
messages: string[],
graphqlErrors?: readonly GraphQLError[] | readonly GraphQLFormattedError[]
) => {
if (graphqlErrors) {
return {
errors: graphqlErrors,
}
}
return {
errors: messages.map((message) => {
return {
message: message,
}
}),
}
}
// export const graphiQLResponse = () => {}