feat!: Centralizes computeContext inputs into one struct

NeedleInAJayStack · NeedleInAJayStack · commit 3014ba0daa83 · 2026-02-08T22:04:00.000-07:00
This allows non-breaking expansion of supported inputs in the future. We also added GraphQLRequest as an additional piece of data to use in context computation.
diff --git a/Examples/HelloWorld/Sources/HelloWorld/HelloWorld.swift b/Examples/HelloWorld/Sources/HelloWorld/HelloWorld.swift
@@ -42,11 +42,11 @@ struct HelloWorld {
         )
 
         let router = Router(context: HummingbirdContext.self)
-        router.graphql(schema: schema, config: .init(allowMissingAcceptHeader: true)) { _, _ in
+        router.graphql(schema: schema, config: .init(allowMissingAcceptHeader: true)) { _ in
             GraphQLContext()
         }
         let webSocketRouter = Router(context: HummingbirdWebSocketContext.self)
-        webSocketRouter.graphqlWebSocket(schema: schema) { _, _ in
+        webSocketRouter.graphqlWebSocket(schema: schema) { _ in
             GraphQLContext()
         }
         let app = Application(
diff --git a/README.md b/README.md
@@ -67,7 +67,7 @@ struct GraphQLContext: Sendable {}
 
 // Create router and register GraphQL
 let router = Router()
-router.graphql(schema: schema) { _, _ in
+router.graphql(schema: schema) { _ in
     return GraphQLContext()
 }
 
@@ -113,7 +113,7 @@ struct MyWebSocketContext: WebSocketRequestContext, RequestContext {
 }
 
 let router = Router(context: MyContext.self)
-router.graphql(schema: schema) { _, _ in
+router.graphql(schema: schema) { _ in
     GraphQLContext()
 }
 let webSocketRouter = Router(context: MyWebSocketContext.self)
@@ -143,7 +143,7 @@ router.graphql(
     config: .init(
         coders: .init(graphQLJSONEncoder: graphQLJSONEncoder)
     )
-) { _, _ in
+) { _ in
     GraphQLContext()
 }
 ```
diff --git a/Sources/GraphQLHummingbird/GraphQLHandler.swift b/Sources/GraphQLHummingbird/GraphQLHandler.swift
@@ -9,5 +9,13 @@ struct GraphQLHandler<
     let schema: GraphQLSchema
     let rootValue: any Sendable
     let config: GraphQLConfig<WebSocketInit>
-    let computeContext: @Sendable (Request, Context) async throws -> GraphQLContext
+    let computeContext: @Sendable (GraphQLContextComputationInputs<Context>) async throws -> GraphQLContext
+}
+
+public struct GraphQLContextComputationInputs<
+    Context: RequestContext
+>: Sendable {
+    public let hummingbirdRequest: Request
+    public let hummingbirdContext: Context
+    public let graphQLRequest: GraphQLRequest
 }
diff --git a/Sources/GraphQLHummingbird/HTTP/GraphQLHandler+HTTP.swift b/Sources/GraphQLHummingbird/HTTP/GraphQLHandler+HTTP.swift
@@ -24,10 +24,15 @@ extension GraphQLHandler {
         guard operationType != .mutation else {
             throw HTTPError(.methodNotAllowed, message: "Mutations using GET are disallowed")
         }
-        let graphqlContext = try await computeContext(request, context)
+        let graphQLContextComputationInputs = GraphQLContextComputationInputs<Context>(
+            hummingbirdRequest: request,
+            hummingbirdContext: context,
+            graphQLRequest: graphQLRequest
+        )
+        let graphQLContext = try await computeContext(graphQLContextComputationInputs)
         let result = await execute(
             graphQLRequest: graphQLRequest,
-            context: graphqlContext,
+            context: graphQLContext,
             additionalValidationRules: config.additionalValidationRules
         )
         return try encodeResponse(result: result, request: request, context: context)
@@ -58,10 +63,15 @@ extension GraphQLHandler {
             throw HTTPError(.unsupportedMediaType)
         }
 
-        let graphqlContext = try await computeContext(request, context)
+        let graphQLContextComputationInputs = GraphQLContextComputationInputs<Context>(
+            hummingbirdRequest: request,
+            hummingbirdContext: context,
+            graphQLRequest: graphQLRequest
+        )
+        let graphQLContext = try await computeContext(graphQLContextComputationInputs)
         let result = await execute(
             graphQLRequest: graphQLRequest,
-            context: graphqlContext,
+            context: graphQLContext,
             additionalValidationRules: config.additionalValidationRules
         )
         return try encodeResponse(result: result, request: request, context: context)
diff --git a/Sources/GraphQLHummingbird/Router+graphql.swift b/Sources/GraphQLHummingbird/Router+graphql.swift
@@ -20,7 +20,7 @@ public extension RouterMethods {
         schema: GraphQLSchema,
         rootValue: any Sendable = (),
         config: GraphQLConfig<EmptyWebSocketInit> = .init(),
-        computeContext: @Sendable @escaping (Request, Context) async throws -> GraphQLContext
+        computeContext: @Sendable @escaping (GraphQLContextComputationInputs<Context>) async throws -> GraphQLContext
     ) -> Self {
         // https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#request
         let handler = GraphQLHandler<Context, GraphQLContext, EmptyWebSocketInit>(
@@ -84,7 +84,7 @@ public extension RouterMethods where Context: WebSocketRequestContext {
         schema: GraphQLSchema,
         rootValue: any Sendable = (),
         config: GraphQLConfig<WebSocketInit> = GraphQLConfig<EmptyWebSocketInit>(),
-        computeContext: @Sendable @escaping (Request, Context) async throws -> GraphQLContext
+        computeContext: @Sendable @escaping (GraphQLContextComputationInputs<Context>) async throws -> GraphQLContext
     ) -> Self {
         let handler = GraphQLHandler<Context, GraphQLContext, WebSocketInit>(
             schema: schema,
@@ -96,12 +96,11 @@ public extension RouterMethods where Context: WebSocketRequestContext {
         ws(path, shouldUpgrade: { request, _ in
             try handler.shouldUpgrade(request: request)
         }) { inbound, outbound, context in
-            let graphQLContext = try await computeContext(context.request, context.requestContext)
             let subProtocol = try handler.negotiateSubProtocol(request: context.request)
             try await handler.handleWebSocket(
                 inbound: inbound,
                 outbound: outbound,
-                graphqlContext: graphQLContext,
+                context: context,
                 subProtocol: subProtocol,
                 logger: context.logger
             )
diff --git a/Sources/GraphQLHummingbird/WebSocket/GraphQLHandler+handleWebSocket.swift b/Sources/GraphQLHummingbird/WebSocket/GraphQLHandler+handleWebSocket.swift
@@ -6,11 +6,11 @@ import Hummingbird
 import HummingbirdWebSocket
 import Logging
 
-extension GraphQLHandler {
+extension GraphQLHandler where Context: WebSocketRequestContext {
     func handleWebSocket(
         inbound: WebSocketInboundStream,
         outbound: WebSocketOutboundWriter,
-        graphqlContext: GraphQLContext,
+        context: WebSocketRouterContext<Context>,
         subProtocol: WebSocketSubProtocol,
         logger: Logger
     ) async throws {
@@ -22,21 +22,33 @@ extension GraphQLHandler {
             let server = GraphQLTransportWS.Server<WebSocketInit, AsyncThrowingStream<GraphQLResult, Error>>(
                 messenger: messenger,
                 onExecute: { graphQLRequest in
-                    try await graphql(
+                    let graphQLContextComputationInputs = GraphQLContextComputationInputs<Context>(
+                        hummingbirdRequest: context.request,
+                        hummingbirdContext: context.requestContext,
+                        graphQLRequest: graphQLRequest
+                    )
+                    let graphQLContext = try await computeContext(graphQLContextComputationInputs)
+                    return try await graphql(
                         schema: self.schema,
                         request: graphQLRequest.query,
                         rootValue: self.rootValue,
-                        context: graphqlContext,
+                        context: graphQLContext,
                         variableValues: graphQLRequest.variables,
                         operationName: graphQLRequest.operationName
                     )
                 },
                 onSubscribe: { graphQLRequest in
-                    try await graphqlSubscribe(
+                    let graphQLContextComputationInputs = GraphQLContextComputationInputs<Context>(
+                        hummingbirdRequest: context.request,
+                        hummingbirdContext: context.requestContext,
+                        graphQLRequest: graphQLRequest
+                    )
+                    let graphQLContext = try await computeContext(graphQLContextComputationInputs)
+                    return try await graphqlSubscribe(
                         schema: self.schema,
                         request: graphQLRequest.query,
                         rootValue: self.rootValue,
-                        context: graphqlContext,
+                        context: graphQLContext,
                         variableValues: graphQLRequest.variables,
                         operationName: graphQLRequest.operationName
                     ).get()
@@ -51,21 +63,33 @@ extension GraphQLHandler {
             let server = GraphQLWS.Server<WebSocketInit, AsyncThrowingStream<GraphQLResult, Error>>(
                 messenger: messenger,
                 onExecute: { graphQLRequest in
-                    try await graphql(
+                    let graphQLContextComputationInputs = GraphQLContextComputationInputs<Context>(
+                        hummingbirdRequest: context.request,
+                        hummingbirdContext: context.requestContext,
+                        graphQLRequest: graphQLRequest
+                    )
+                    let graphQLContext = try await computeContext(graphQLContextComputationInputs)
+                    return try await graphql(
                         schema: self.schema,
                         request: graphQLRequest.query,
                         rootValue: self.rootValue,
-                        context: graphqlContext,
+                        context: graphQLContext,
                         variableValues: graphQLRequest.variables,
                         operationName: graphQLRequest.operationName
                     )
                 },
                 onSubscribe: { graphQLRequest in
-                    try await graphqlSubscribe(
+                    let graphQLContextComputationInputs = GraphQLContextComputationInputs<Context>(
+                        hummingbirdRequest: context.request,
+                        hummingbirdContext: context.requestContext,
+                        graphQLRequest: graphQLRequest
+                    )
+                    let graphQLContext = try await computeContext(graphQLContextComputationInputs)
+                    return try await graphqlSubscribe(
                         schema: self.schema,
                         request: graphQLRequest.query,
                         rootValue: self.rootValue,
-                        context: graphqlContext,
+                        context: graphQLContext,
                         variableValues: graphQLRequest.variables,
                         operationName: graphQLRequest.operationName
                     ).get()
diff --git a/Tests/GraphQLHummingbirdTests/HTTPStatusCodeGraphQLJSONTests.swift b/Tests/GraphQLHummingbirdTests/HTTPStatusCodeGraphQLJSONTests.swift
@@ -16,7 +16,7 @@ struct HTTPStatusCodeGraphQLJSONTests {
     @Test func parsingFailureGivesBadRequest() async throws {
         // https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#json-parsing-failure-1
         let router = Router()
-        router.graphql(schema: helloWorldSchema) { _, _ in
+        router.graphql(schema: helloWorldSchema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
@@ -36,7 +36,7 @@ struct HTTPStatusCodeGraphQLJSONTests {
     @Test func invalidParametersGivesBadRequest() async throws {
         // https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#invalid-parameters-1
         let router = Router()
-        router.graphql(schema: helloWorldSchema) { _, _ in
+        router.graphql(schema: helloWorldSchema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
@@ -56,7 +56,7 @@ struct HTTPStatusCodeGraphQLJSONTests {
     @Test func documentParsingFailureGivesBadRequest() async throws {
         // https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#document-parsing-failure-1
         let router = Router()
-        router.graphql(schema: helloWorldSchema) { _, _ in
+        router.graphql(schema: helloWorldSchema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
@@ -76,7 +76,7 @@ struct HTTPStatusCodeGraphQLJSONTests {
     @Test func documentValidationFailureGivesBadRequest() async throws {
         // https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#document-validation-failure-1
         let router = Router()
-        router.graphql(schema: helloWorldSchema) { _, _ in
+        router.graphql(schema: helloWorldSchema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
@@ -97,7 +97,7 @@ struct HTTPStatusCodeGraphQLJSONTests {
     @Test func operationCannotBeDeterminedGivesBadRequest() async throws {
         // https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#operation-cannot-be-determined-1
         let router = Router()
-        router.graphql(schema: helloWorldSchema) { _, _ in
+        router.graphql(schema: helloWorldSchema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
@@ -136,7 +136,7 @@ struct HTTPStatusCodeGraphQLJSONTests {
             )
         )
         let router = Router()
-        router.graphql(schema: schema) { _, _ in
+        router.graphql(schema: schema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
@@ -171,7 +171,7 @@ struct HTTPStatusCodeGraphQLJSONTests {
             )
         )
         let router = Router()
-        router.graphql(schema: schema) { _, _ in
+        router.graphql(schema: schema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
diff --git a/Tests/GraphQLHummingbirdTests/HTTPStatusCodeJSONTests.swift b/Tests/GraphQLHummingbirdTests/HTTPStatusCodeJSONTests.swift
@@ -16,7 +16,7 @@ struct HTTPStatusCodeJSONTests {
     @Test func parsingFailureGivesBadRequest() async throws {
         // https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#json-parsing-failure
         let router = Router()
-        router.graphql(schema: helloWorldSchema) { _, _ in
+        router.graphql(schema: helloWorldSchema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
@@ -36,7 +36,7 @@ struct HTTPStatusCodeJSONTests {
     @Test func invalidParametersGivesBadRequest() async throws {
         // https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#invalid-parameters
         let router = Router()
-        router.graphql(schema: helloWorldSchema) { _, _ in
+        router.graphql(schema: helloWorldSchema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
@@ -56,7 +56,7 @@ struct HTTPStatusCodeJSONTests {
     @Test func documentValidationFailureGivesOk() async throws {
         // https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#document-validation-failure
         let router = Router()
-        router.graphql(schema: helloWorldSchema) { _, _ in
+        router.graphql(schema: helloWorldSchema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
@@ -77,7 +77,7 @@ struct HTTPStatusCodeJSONTests {
     @Test func documentParsingFailureGivesOk() async throws {
         // https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#document-parsing-failure
         let router = Router()
-        router.graphql(schema: helloWorldSchema) { _, _ in
+        router.graphql(schema: helloWorldSchema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
@@ -116,7 +116,7 @@ struct HTTPStatusCodeJSONTests {
             )
         )
         let router = Router()
-        router.graphql(schema: schema) { _, _ in
+        router.graphql(schema: schema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
@@ -138,7 +138,7 @@ struct HTTPStatusCodeJSONTests {
     @Test func operationCannotBeDeterminedGivesOk() async throws {
         // https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#operation-cannot-be-determined
         let router = Router()
-        router.graphql(schema: helloWorldSchema) { _, _ in
+        router.graphql(schema: helloWorldSchema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
@@ -171,7 +171,7 @@ struct HTTPStatusCodeJSONTests {
             )
         )
         let router = Router()
-        router.graphql(schema: schema) { _, _ in
+        router.graphql(schema: schema) { _ in
             EmptyContext()
         }
         let app = Application(router: router)
diff --git a/Tests/GraphQLHummingbirdTests/HTTPTests.swift b/Tests/GraphQLHummingbirdTests/HTTPTests.swift
diff --git a/Tests/GraphQLHummingbirdTests/WebSocketTests.swift b/Tests/GraphQLHummingbirdTests/WebSocketTests.swift

Original file line number	Diff line number	Diff line change
`@@ -42,11 +42,11 @@ struct HelloWorld {`
`42`	`42`	`)`
`43`	`43`
`44`	`44`	`let router = Router(context: HummingbirdContext.self)`
`45`		`- router.graphql(schema: schema, config: .init(allowMissingAcceptHeader: true)) { _, _ in`
	`45`	`+ router.graphql(schema: schema, config: .init(allowMissingAcceptHeader: true)) { _ in`
`46`	`46`	`GraphQLContext()`
`47`	`47`	`}`
`48`	`48`	`let webSocketRouter = Router(context: HummingbirdWebSocketContext.self)`
`49`		`- webSocketRouter.graphqlWebSocket(schema: schema) { _, _ in`
	`49`	`+ webSocketRouter.graphqlWebSocket(schema: schema) { _ in`
`50`	`50`	`GraphQLContext()`
`51`	`51`	`}`
`52`	`52`	`let app = Application(`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ struct GraphQLContext: Sendable {}`
`67`	`67`
`68`	`68`	`// Create router and register GraphQL`
`69`	`69`	`let router = Router()`
`70`		`-router.graphql(schema: schema) { _, _ in`
	`70`	`+router.graphql(schema: schema) { _ in`
`71`	`71`	`return GraphQLContext()`
`72`	`72`	`}`
`73`	`73`
`@@ -113,7 +113,7 @@ struct MyWebSocketContext: WebSocketRequestContext, RequestContext {`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`let router = Router(context: MyContext.self)`
`116`		`-router.graphql(schema: schema) { _, _ in`
	`116`	`+router.graphql(schema: schema) { _ in`
`117`	`117`	`GraphQLContext()`
`118`	`118`	`}`
`119`	`119`	`let webSocketRouter = Router(context: MyWebSocketContext.self)`
`@@ -143,7 +143,7 @@ router.graphql(`
`143`	`143`	`config: .init(`
`144`	`144`	`coders: .init(graphQLJSONEncoder: graphQLJSONEncoder)`
`145`	`145`	`)`
`146`		`-) { _, _ in`
	`146`	`+) { _ in`
`147`	`147`	`GraphQLContext()`
`148`	`148`	`}`
`149`	`149`	```
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ struct HTTPStatusCodeGraphQLJSONTests {`
`16`	`16`	`@Test func parsingFailureGivesBadRequest() async throws {`
`17`	`17`	`// https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#json-parsing-failure-1`
`18`	`18`	`let router = Router()`
`19`		`- router.graphql(schema: helloWorldSchema) { _, _ in`
	`19`	`+ router.graphql(schema: helloWorldSchema) { _ in`
`20`	`20`	`EmptyContext()`
`21`	`21`	`}`
`22`	`22`	`let app = Application(router: router)`
`@@ -36,7 +36,7 @@ struct HTTPStatusCodeGraphQLJSONTests {`
`36`	`36`	`@Test func invalidParametersGivesBadRequest() async throws {`
`37`	`37`	`// https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#invalid-parameters-1`
`38`	`38`	`let router = Router()`
`39`		`- router.graphql(schema: helloWorldSchema) { _, _ in`
	`39`	`+ router.graphql(schema: helloWorldSchema) { _ in`
`40`	`40`	`EmptyContext()`
`41`	`41`	`}`
`42`	`42`	`let app = Application(router: router)`
`@@ -56,7 +56,7 @@ struct HTTPStatusCodeGraphQLJSONTests {`
`56`	`56`	`@Test func documentParsingFailureGivesBadRequest() async throws {`
`57`	`57`	`// https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#document-parsing-failure-1`
`58`	`58`	`let router = Router()`
`59`		`- router.graphql(schema: helloWorldSchema) { _, _ in`
	`59`	`+ router.graphql(schema: helloWorldSchema) { _ in`
`60`	`60`	`EmptyContext()`
`61`	`61`	`}`
`62`	`62`	`let app = Application(router: router)`
`@@ -76,7 +76,7 @@ struct HTTPStatusCodeGraphQLJSONTests {`
`76`	`76`	`@Test func documentValidationFailureGivesBadRequest() async throws {`
`77`	`77`	`// https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#document-validation-failure-1`
`78`	`78`	`let router = Router()`
`79`		`- router.graphql(schema: helloWorldSchema) { _, _ in`
	`79`	`+ router.graphql(schema: helloWorldSchema) { _ in`
`80`	`80`	`EmptyContext()`
`81`	`81`	`}`
`82`	`82`	`let app = Application(router: router)`
`@@ -97,7 +97,7 @@ struct HTTPStatusCodeGraphQLJSONTests {`
`97`	`97`	`@Test func operationCannotBeDeterminedGivesBadRequest() async throws {`
`98`	`98`	`// https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#operation-cannot-be-determined-1`
`99`	`99`	`let router = Router()`
`100`		`- router.graphql(schema: helloWorldSchema) { _, _ in`
	`100`	`+ router.graphql(schema: helloWorldSchema) { _ in`
`101`	`101`	`EmptyContext()`
`102`	`102`	`}`
`103`	`103`	`let app = Application(router: router)`
`@@ -136,7 +136,7 @@ struct HTTPStatusCodeGraphQLJSONTests {`
`136`	`136`	`)`
`137`	`137`	`)`
`138`	`138`	`let router = Router()`
`139`		`- router.graphql(schema: schema) { _, _ in`
	`139`	`+ router.graphql(schema: schema) { _ in`
`140`	`140`	`EmptyContext()`
`141`	`141`	`}`
`142`	`142`	`let app = Application(router: router)`
`@@ -171,7 +171,7 @@ struct HTTPStatusCodeGraphQLJSONTests {`
`171`	`171`	`)`
`172`	`172`	`)`
`173`	`173`	`let router = Router()`
`174`		`- router.graphql(schema: schema) { _, _ in`
	`174`	`+ router.graphql(schema: schema) { _ in`
`175`	`175`	`EmptyContext()`
`176`	`176`	`}`
`177`	`177`	`let app = Application(router: router)`