feat(GraphQL): support application/graphql-response+json requests

src/core/handlers/GraphQLHandler.ts

@@ -1,6 +1,8 @@
 import type { DocumentNode, GraphQLError, OperationTypeNode } from 'graphql'
 import {
+  AsyncResponseResolverReturnType,
   DefaultBodyType,
+  MaybeAsyncResponseResolverReturnType,
   RequestHandler,
   RequestHandlerDefaultInfo,
   RequestHandlerOptions,
@@ -19,7 +21,11 @@
 } from '../utils/internal/parseGraphQLRequest'
 import { toPublicUrl } from '../utils/request/toPublicUrl'
 import { devUtils } from '../utils/internal/devUtils'
-import { getAllRequestCookies } from '../utils/request/getRequestCookies'
+import {
+  getAllAcceptedMimeTypes,
+  getAllRequestCookies,
+} from '../utils/request/getRequestCookies'
+import { isIterable } from '../utils/internal/isIterable'
 
 export type ExpectedOperationTypeNode = OperationTypeNode | 'all'
 export type GraphQLHandlerNameSelector = DocumentNode | RegExp | string
@@ -32,6 +38,12 @@
   operationName: GraphQLHandlerNameSelector
 }
 
+export type GraphQLMimeType =
+  | 'application/graphql-response+json'
+  | 'application/json'
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | (string & {})
+
 export type GraphQLRequestParsedResult = {
   match: Match
   cookies: Record<string, string>
@@ -86,6 +98,10 @@
   return typeof value === 'object' && 'kind' in value && 'definitions' in value
 }
 
+export interface GraphQLHandlerOptions extends RequestHandlerOptions {
+  supportedMimeTypes?: GraphQLMimeType[]
+}
+
 export class GraphQLHandler extends RequestHandler<
   GraphQLHandlerInfo,
   GraphQLRequestParsedResult,
@@ -103,7 +119,7 @@
     operationName: GraphQLHandlerNameSelector,
     endpoint: Path,
     resolver: ResponseResolver<GraphQLResolverExtras<any>, any, any>,
-    options?: RequestHandlerOptions,
+    options?: GraphQLHandlerOptions,
   ) {
     let resolvedOperationName = operationName
 
@@ -130,13 +146,65 @@
         ? `${operationType} (origin: ${endpoint.toString()})`
         : `${operationType} ${resolvedOperationName} (origin: ${endpoint.toString()})`
 
+    const supportedMimeTypes = options?.supportedMimeTypes || [
+      'application/graphql-response+json',
+      'application/json',
+    ]
+
+    const wrappedResolver: typeof resolver = (info) => {
+      function handleSingleResult(
+        singleResult: MaybeAsyncResponseResolverReturnType<any>,
+      ): MaybeAsyncResponseResolverReturnType<any> {
+        if (!singleResult) return
+        if ('then' in singleResult) {
+          return singleResult.then(handleSingleResult)
+        }
+        if (!singleResult) return singleResult
+        const acceptedMimeTypes = getAllAcceptedMimeTypes(
+          info.request,
+          'application/json',
+        )
+        const mimeType = acceptedMimeTypes.find((type) =>
+          supportedMimeTypes.includes(type),
+        )
+        if (!mimeType) return singleResult
+        const clone = singleResult.clone()
+        clone.headers.set('Content-Type', mimeType)
+        return clone
+      }
+      function* handleGeneratorResult(
+        generatorResult: Extract<
+          AsyncResponseResolverReturnType<any>,
+          Generator
+        >,
+      ): Extract<AsyncResponseResolverReturnType<any>, Generator> {
+        for (const result of generatorResult) {
+          yield handleSingleResult(result)
+        }
+      }
+      function handleResult(
+        originalResult: AsyncResponseResolverReturnType<any>,
+      ): AsyncResponseResolverReturnType<any> {
+        if (!originalResult) return originalResult
+        if ('then' in originalResult) {
+          return originalResult.then(handleResult)
+        }
+        if (isIterable(originalResult)) {
+          return handleGeneratorResult(originalResult)
+        }
+        return handleSingleResult(originalResult)
+      }
+
+      return handleResult(resolver(info))
+    }
+
     super({
       info: {
         header,
         operationType,
         operationName: resolvedOperationName,
       },
-      resolver,
+      resolver: wrappedResolver,
       options,
     })
 

src/core/utils/request/getRequestCookies.ts

@@ -37,6 +37,40 @@ export function getRequestCookies(request: Request): Record<string, string> {
   }
 }
 
+/**
+ * Returns all accepted mime types, ordered by priority
+ * So
+ * `"application/graphql-response+json, application/json;q=0.9"`
+ * would become
+ * ["application/graphql-response+json", "application/json"]
+ * and
+ * `"application/graphql-response+json, application/json;q=1.1"`
+ * would become
+ * ["application/json", "application/graphql-response+json"]
+ *
+ * Currently only takes into account quality weight, not other priority
+ * heuristics as described in [RFC7231 Sec 5.3.2](https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2)
+ */
+export function getAllAcceptedMimeTypes(
+  request: Request,
+  fallback: string,
+): string[] {
+  const accepted: Array<{ type: string; weight: number }> = []
+  for (const part of (request.headers.get('accept') || '').split(',')) {
+    const [type, ...params] = part.split(';').map((v) => v.trim())
+    const entry: (typeof accepted)[number] = { type, weight: 1 }
+    for (const param of params) {
+      const [key, value] = param.split('=').map((v) => v.trim())
+      if (key === 'weight') {
+        entry.weight = Number(value)
+      }
+    }
+    accepted.push(entry)
+  }
+  if (!accepted.length) return [fallback]
+  return accepted.sort((a, b) => a.weight - b.weight).map((entry) => entry.type)
+}
+
 export function getAllRequestCookies(request: Request): Record<string, string> {
   const requestCookiesString = request.headers.get('cookie')
   const cookiesFromHeaders = requestCookiesString